Add new comparison operators

Author: Gijsreyn

dsc/tests/dsc_expressions.tests.ps1

@@ -112,6 +112,18 @@ resources:
         @{ expression = "[equals('a', 'a')]"; expected = $true }
         @{ expression = "[equals('a', 'b')]"; expected = $false }
         @{ expression = "[not(equals('a', 'b'))]"; expected = $true }
+        @{ expression = "[greater(5, 3)]"; expected = $true }
+        @{ expression = "[greater(3, 5)]"; expected = $false }
+        @{ expression = "[greater(5, 5)]"; expected = $false }
+        @{ expression = "[greaterOrEquals(5, 3)]"; expected = $true }
+        @{ expression = "[greaterOrEquals(3, 5)]"; expected = $false }
+        @{ expression = "[greaterOrEquals(5, 5)]"; expected = $true }
+        @{ expression = "[less(3, 5)]"; expected = $true }
+        @{ expression = "[less(5, 3)]"; expected = $false }
+        @{ expression = "[less(5, 5)]"; expected = $false }
+        @{ expression = "[lessOrEquals(3, 5)]"; expected = $true }
+        @{ expression = "[lessOrEquals(5, 3)]"; expected = $false }
+        @{ expression = "[lessOrEquals(5, 5)]"; expected = $true }
         @{ expression = "[and(true, true)]"; expected = $true }
         @{ expression = "[and(true, false)]"; expected = $false }
         @{ expression = "[or(false, true)]"; expected = $true }

dsc_lib/locales/en-us.toml

@@ -248,6 +248,14 @@ description = "Evaluates if the two values are the same"
 description = "Returns the boolean value false"
 invoked = "false function"
 
+[functions.greater]
+description = "Evaluates if the first value is greater than the second value"
+invoked = "greater function"
+
+[functions.greaterOrEquals]
+description = "Evaluates if the first value is greater than or equal to the second value"
+invoked = "greaterOrEquals function"
+
 [functions.format]
 description = "Formats a string using the given arguments"
 experimental = "`format()` function is experimental"
@@ -267,6 +275,14 @@ parseStringError = "unable to parse string to int"
 castError = "unable to cast to int"
 parseNumError = "unable to parse number to int"
 
+[functions.less]
+description = "Evaluates if the first value is less than the second value"
+invoked = "less function"
+
+[functions.lessOrEquals]
+description = "Evaluates if the first value is less than or equal to the second value"
+invoked = "lessOrEquals function"
+
 [functions.max]
 description = "Returns the largest number from a list of numbers"
 emptyArray = "Array cannot be empty"

dsc_lib/src/functions/greater.rs

@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::DscError;
+use crate::configure::context::Context;
+use crate::functions::{AcceptedArgKind, FunctionCategory};
+use rust_i18n::t;
+use super::Function;
+use serde_json::Value;
+
+#[derive(Debug, Default)]
+pub struct Greater {}
+
+impl Function for Greater {
+    fn description(&self) -> String {
+        t!("functions.greater.description").to_string()
+    }
+
+    fn category(&self) -> FunctionCategory {
+        FunctionCategory::Comparison
+    }
+
+    fn accepted_arg_types(&self) -> Vec<AcceptedArgKind> {
+        vec![AcceptedArgKind::Number, AcceptedArgKind::String]
+    }
+
+    fn min_args(&self) -> usize {
+        2
+    }
+
+    fn max_args(&self) -> usize {
+        2
+    }
+
+    fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
+        let first = &args[0];
+        let second = &args[1];
+
+        if let (Some(num1), Some(num2)) = (first.as_f64(), second.as_f64()) {
+            return Ok(Value::Bool(num1 > num2));
+        }
+
+        if let (Some(str1), Some(str2)) = (first.as_str(), second.as_str()) {
+            return Ok(Value::Bool(str1 > str2));
+        }
+
+        Ok(Value::Bool(false))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::configure::context::Context;
+    use crate::parser::Statement;
+    use serde_json::Value;
+
+    #[test]
+    fn number_greater() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[greater(2,1)]", &Context::new()).unwrap();
+        assert_eq!(result, Value::Bool(true));
+    }
+
+    #[test]
+    fn number_not_greater() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[greater(1,2)]", &Context::new()).unwrap();
+        assert_eq!(result, Value::Bool(false));
+    }
+
+    #[test]
+    fn number_equal() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[greater(1,1)]", &Context::new()).unwrap();
+        assert_eq!(result, Value::Bool(false));
+    }
+}

dsc_lib/src/functions/greater_or_equals.rs

@@ -0,0 +1,83 @@
+// 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 GreaterOrEquals {}
+
+impl Function for GreaterOrEquals {
+    fn description(&self) -> String {
+        t!("functions.greaterOrEquals.description").to_string()
+    }
+
+    fn category(&self) -> FunctionCategory {
+        FunctionCategory::Comparison
+    }
+
+    fn min_args(&self) -> usize {
+        2
+    }
+
+    fn max_args(&self) -> usize {
+        2
+    }
+
+    fn accepted_arg_types(&self) -> Vec<AcceptedArgKind> {
+        vec![AcceptedArgKind::Number, AcceptedArgKind::Number]
+    }
+
+    fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
+        debug!("{}", t!("functions.greaterOrEquals.invoked"));
+        
+        let num1 = match &args[0] {
+            Value::Number(n) => n.as_f64().ok_or_else(|| DscError::Parser(t!("functions.invalidArguments").to_string()))?,
+            _ => return Err(DscError::Parser(t!("functions.invalidArguments").to_string())),
+        };
+
+        let num2 = match &args[1] {
+            Value::Number(n) => n.as_f64().ok_or_else(|| DscError::Parser(t!("functions.invalidArguments").to_string()))?,
+            _ => return Err(DscError::Parser(t!("functions.invalidArguments").to_string())),
+        };
+
+        Ok(Value::Bool(num1 >= num2))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::configure::context::Context;
+
+    #[test]
+    fn test_greater_or_equals() {
+        let greater_or_equals = GreaterOrEquals {};
+        let context = Context::new().unwrap();
+        
+        let result = greater_or_equals.invoke(&[Value::Number(5.into()), Value::Number(3.into())], &context);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Value::Bool(true));
+        
+        let result = greater_or_equals.invoke(&[Value::Number(3.into()), Value::Number(5.into())], &context);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Value::Bool(false));
+        
+        let result = greater_or_equals.invoke(&[Value::Number(5.into()), Value::Number(5.into())], &context);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Value::Bool(true));
+    }
+
+    #[test]
+    fn test_invalid_args() {
+        let greater_or_equals = GreaterOrEquals {};
+        let context = Context::new().unwrap();
+        
+        let result = greater_or_equals.invoke(&[Value::Number(5.into())], &context);
+        assert!(result.is_err());
+    }
+}

dsc_lib/src/functions/less.rs

@@ -0,0 +1,83 @@
+// 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 Less {}
+
+impl Function for Less {
+    fn description(&self) -> String {
+        t!("functions.less.description").to_string()
+    }
+
+    fn category(&self) -> FunctionCategory {
+        FunctionCategory::Comparison
+    }
+
+    fn min_args(&self) -> usize {
+        2
+    }
+
+    fn max_args(&self) -> usize {
+        2
+    }
+
+    fn accepted_arg_types(&self) -> Vec<AcceptedArgKind> {
+        vec![AcceptedArgKind::Number, AcceptedArgKind::Number]
+    }
+
+    fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
+        debug!("{}", t!("functions.less.invoked"));
+        
+        let num1 = match &args[0] {
+            Value::Number(n) => n.as_f64().ok_or_else(|| DscError::Parser(t!("functions.invalidArguments").to_string()))?,
+            _ => return Err(DscError::Parser(t!("functions.invalidArguments").to_string())),
+        };
+
+        let num2 = match &args[1] {
+            Value::Number(n) => n.as_f64().ok_or_else(|| DscError::Parser(t!("functions.invalidArguments").to_string()))?,
+            _ => return Err(DscError::Parser(t!("functions.invalidArguments").to_string())),
+        };
+
+        Ok(Value::Bool(num1 < num2))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::configure::context::Context;
+
+    #[test]
+    fn test_less() {
+        let less = Less {};
+        let context = Context::new().unwrap();
+        
+        let result = less.invoke(&[Value::Number(3.into()), Value::Number(5.into())], &context);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Value::Bool(true));
+        
+        let result = less.invoke(&[Value::Number(5.into()), Value::Number(3.into())], &context);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Value::Bool(false));
+        
+        let result = less.invoke(&[Value::Number(5.into()), Value::Number(5.into())], &context);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Value::Bool(false));
+    }
+
+    #[test]
+    fn test_invalid_args() {
+        let less = Less {};
+        let context = Context::new().unwrap();
+        
+        let result = less.invoke(&[Value::Number(5.into())], &context);
+        assert!(result.is_err());
+    }
+}

dsc_lib/src/functions/less_or_equals.rs

@@ -0,0 +1,83 @@
+// 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 LessOrEquals {}
+
+impl Function for LessOrEquals {
+    fn description(&self) -> String {
+        t!("functions.lessOrEquals.description").to_string()
+    }
+
+    fn category(&self) -> FunctionCategory {
+        FunctionCategory::Comparison
+    }
+
+    fn min_args(&self) -> usize {
+        2
+    }
+
+    fn max_args(&self) -> usize {
+        2
+    }
+
+    fn accepted_arg_types(&self) -> Vec<AcceptedArgKind> {
+        vec![AcceptedArgKind::Number, AcceptedArgKind::Number]
+    }
+
+    fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
+        debug!("{}", t!("functions.lessOrEquals.invoked"));
+        
+        let num1 = match &args[0] {
+            Value::Number(n) => n.as_f64().ok_or_else(|| DscError::Parser(t!("functions.invalidArguments").to_string()))?,
+            _ => return Err(DscError::Parser(t!("functions.invalidArguments").to_string())),
+        };
+
+        let num2 = match &args[1] {
+            Value::Number(n) => n.as_f64().ok_or_else(|| DscError::Parser(t!("functions.invalidArguments").to_string()))?,
+            _ => return Err(DscError::Parser(t!("functions.invalidArguments").to_string())),
+        };
+
+        Ok(Value::Bool(num1 <= num2))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::configure::context::Context;
+
+    #[test]
+    fn test_less_or_equals() {
+        let less_or_equals = LessOrEquals {};
+        let context = Context::new().unwrap();
+        
+        let result = less_or_equals.invoke(&[Value::Number(3.into()), Value::Number(5.into())], &context);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Value::Bool(true));
+        
+        let result = less_or_equals.invoke(&[Value::Number(5.into()), Value::Number(3.into())], &context);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Value::Bool(false));
+        
+        let result = less_or_equals.invoke(&[Value::Number(5.into()), Value::Number(5.into())], &context);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Value::Bool(true));
+    }
+
+    #[test]
+    fn test_invalid_args() {
+        let less_or_equals = LessOrEquals {};
+        let context = Context::new().unwrap();
+        
+        let result = less_or_equals.invoke(&[Value::Number(5.into())], &context);
+        assert!(result.is_err());
+    }
+}