feat: added operator.NotIn for arrays

Author: carlosgoias

src/Rules.Framework/Builder/Validation/ValueConditionNodeValidator.cs

@@ -49,22 +49,22 @@ public ValueConditionNodeValidator()
                 .WithMessage(cn => $"Condition nodes with data type '{cn.DataType}' can't define a operator of type '{cn.Operator}'.");
 
             this.RuleFor(c => c.Operator)
-                .IsContainedOn(Operators.In)
+                .IsContainedOn(Operators.In, Operators.NotIn, Operators.Equal, Operators.NotEqual)
                 .When(c => c.DataType == DataTypes.ArrayString)
                 .WithMessage(cn => $"Condition nodes with data type '{cn.DataType}' can't define a operator of type '{cn.Operator}'.");
 
             this.RuleFor(c => c.Operator)
-                .IsContainedOn(Operators.In)
+                .IsContainedOn(Operators.In, Operators.NotIn, Operators.Equal, Operators.NotEqual)
                 .When(c => c.DataType == DataTypes.ArrayInteger)
                 .WithMessage(cn => $"Condition nodes with data type '{cn.DataType}' can't define a operator of type '{cn.Operator}'.");
 
             this.RuleFor(c => c.Operator)
-                .IsContainedOn(Operators.In)
+                .IsContainedOn(Operators.In, Operators.NotIn, Operators.Equal, Operators.NotEqual)
                 .When(c => c.DataType == DataTypes.ArrayDecimal)
                 .WithMessage(cn => $"Condition nodes with data type '{cn.DataType}' can't define a operator of type '{cn.Operator}'.");
 
             this.RuleFor(c => c.Operator)
-                .IsContainedOn(Operators.In)
+                .IsContainedOn(Operators.In, Operators.NotIn, Operators.Equal, Operators.NotEqual)
                 .When(c => c.DataType == DataTypes.ArrayBoolean)
                 .WithMessage(cn => $"Condition nodes with data type '{cn.DataType}' can't define a operator of type '{cn.Operator}'.");
         }

src/Rules.Framework/Core/Operators.cs

@@ -78,6 +78,11 @@ public enum Operators
         /// <summary>
         /// The not ends with operator.
         /// </summary>
-        NotEndsWith = 15
+        NotEndsWith = 15,
+
+        /// <summary>
+        /// The not in operator.
+        /// </summary>
+        NotIn = 16,
     }
 }

src/Rules.Framework/Evaluation/OperatorsMetadata.cs

@@ -23,6 +23,7 @@ internal static class OperatorsMetadata
             OperatorsMetadata.Contains,
             OperatorsMetadata.NotContains,
             OperatorsMetadata.In,
+            OperatorsMetadata.NotIn,
             OperatorsMetadata.StartsWith,
             OperatorsMetadata.EndsWith,
             OperatorsMetadata.CaseInsensitiveStartsWith,
@@ -138,6 +139,12 @@ static OperatorsMetadata()
             SupportedMultiplicities = new[] { Multiplicities.OneToOne },
         };
 
+        public static OperatorMetadata NotIn => new()
+        {
+            Operator = Operators.NotIn,
+            SupportedMultiplicities = new[] { Multiplicities.OneToMany },
+        };
+
         public static OperatorMetadata NotStartsWith => new()
         {
             Operator = Operators.NotStartsWith,

src/Rules.Framework/Evaluation/ValueEvaluation/NotInOperatorEvalStrategy.cs

@@ -0,0 +1,11 @@
+namespace Rules.Framework.Evaluation.ValueEvaluation
+{
+    using System.Collections.Generic;
+    using System.Linq;
+
+    internal sealed class NotInOperatorEvalStrategy : IOneToManyOperatorEvalStrategy
+    {
+        public bool Eval(object leftOperand, IEnumerable<object> rightOperand)
+            => !rightOperand.Contains(leftOperand);
+    }
+}

src/Rules.Framework/Evaluation/ValueEvaluation/OperatorEvalStrategyFactory.cs

@@ -21,6 +21,7 @@ public OperatorEvalStrategyFactory()
                 { Operators.Contains, new ContainsOperatorEvalStrategy() },
                 { Operators.NotContains, new NotContainsOperatorEvalStrategy() },
                 { Operators.In, new InOperatorEvalStrategy() },
+                { Operators.NotIn, new NotInOperatorEvalStrategy() },
                 { Operators.StartsWith, new StartsWithOperatorEvalStrategy() },
                 { Operators.EndsWith, new EndsWithOperatorEvalStrategy() },
                 { Operators.CaseInsensitiveStartsWith, new CaseInsensitiveStartsWithOperatorEvalStrategy() },

tests/Rules.Framework.Tests/Evaluation/ValueEvaluation/NotInOperatorEvalStrategyTests.cs

@@ -0,0 +1,42 @@
+namespace Rules.Framework.Tests.Evaluation.ValueEvaluation
+{
+    using System.Linq;
+    using FluentAssertions;
+    using Rules.Framework.Evaluation.ValueEvaluation;
+    using Xunit;
+
+    public class NotInOperatorEvalStrategyTests
+    {
+        [Fact]
+        public void Eval_GivenInteger1AndCollectionContainingInteger1_ReturnsFalse()
+        {
+            // Arrange
+            object leftOperand = 1;
+            var rightOperand = Enumerable.Range(1, 3).Cast<object>();
+
+            var notInOperatorEvalStrategy = new NotInOperatorEvalStrategy();
+
+            // Act
+            var result = notInOperatorEvalStrategy.Eval(leftOperand, rightOperand);
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Eval_GivenInteger2AndCollectionNotContainingInteger2_ReturnsTrue()
+        {
+            // Arrange
+            object leftOperand = 2;
+            var rightOperand = Enumerable.Range(6, 3).Cast<object>();
+
+            var notInOperatorEvalStrategy = new NotInOperatorEvalStrategy();
+
+            // Act
+            var result = notInOperatorEvalStrategy.Eval(leftOperand, rightOperand);
+
+            // Assert
+            result.Should().BeTrue();
+        }
+    }
+}