#6 - allow to assign to IType.Explanation by CustomRule

sources/NetArchTest/Condition.cs

@@ -214,5 +214,24 @@ public ConditionList MeetCustomRule(Func<TypeDefinition, bool> rule)
             AddFunctionCall(x => FunctionDelegates.MeetCustomRule(x, rule, true));
             return CreateConditionList();
         }
+        /// <summary>
+        /// Selects types that meet a custom rule.
+        /// </summary>
+        /// <param name="rule">An instance of the custom rule.</param>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList MeetCustomRule(ICustomRule2 rule)
+        {
+            AddFunctionCall(x => FunctionDelegates.MeetCustomRule(x, rule, true));
+            return CreateConditionList();
+        }
+        /// <summary>
+        /// Selects types that meet a custom rule.
+        /// </summary>        
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList MeetCustomRule(Func<TypeDefinition, CustomRuleResult> rule)
+        {
+            AddFunctionCall(x => FunctionDelegates.MeetCustomRule(x, rule, true));
+            return CreateConditionList();
+        }
     }
 }

sources/NetArchTest/Functions/FunctionDelegates.cs

@@ -113,5 +113,42 @@ internal static IEnumerable<TypeSpec> MeetCustomRule(IEnumerable<TypeSpec> input
                 return input.Where(t => !rule(t.Definition));
             }
         }
+
+        internal static IEnumerable<TypeSpec> MeetCustomRule(IEnumerable<TypeSpec> input, ICustomRule2 rule, bool condition)
+        {
+            var ruleDelegate = rule.MeetsRule;
+
+            if (condition)
+            {
+                return input.Where(t => ExecuteCustomRule(t, ruleDelegate));
+            }
+            else
+            {
+                return input.Where(t => !ExecuteCustomRule(t, ruleDelegate));
+            }
+        }
+
+        internal static IEnumerable<TypeSpec> MeetCustomRule(IEnumerable<TypeSpec> input, Func<TypeDefinition, CustomRuleResult> rule, bool condition)
+        {
+            if (condition)
+            {
+                return input.Where(t => ExecuteCustomRule(t, rule));
+            }
+            else
+            {
+                return input.Where(t => !ExecuteCustomRule(t, rule));
+            }
+        }
+
+
+        private static bool ExecuteCustomRule(TypeSpec inputType, Func<TypeDefinition, CustomRuleResult> rule)
+        {
+            var result = rule.Invoke(inputType.Definition);
+            if (!string.IsNullOrEmpty(result.Explanation))
+            {
+                inputType.Explanation = result.Explanation;
+            }
+            return result.IsMet;
+        }
     }
 }

sources/NetArchTest/ICustomRule.cs

@@ -14,4 +14,34 @@ public interface ICustomRule
         /// <returns>The result of the test.</returns>
         bool MeetsRule(TypeDefinition type);
     }
+
+
+
+    /// <summary>
+    /// An externally defined rule that can be applied as a condition or a predicate.
+    /// </summary>
+    public interface ICustomRule2
+    {
+        /// <summary>
+        /// Tests whether the supplied type meets the rule.
+        /// </summary>
+        /// <param name="type">The type to be tested.</param>
+        /// <returns>The result of the test.</returns>
+        CustomRuleResult MeetsRule(TypeDefinition type);
+    }
+
+
+    public class CustomRuleResult
+    {
+        public bool IsMet { get; init; }
+
+        public string Explanation { get; init; }
+
+
+        public CustomRuleResult(bool isMet, string explanation = null)
+        {
+            IsMet = isMet;
+            Explanation = explanation;
+        }
+    }
 }

sources/NetArchTest/NetArchTest.csproj

@@ -16,7 +16,7 @@
     <GenerateDocumentationFile>true</GenerateDocumentationFile>    
     <PackageId>NetArchTest.eNhancedEdition </PackageId>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
-	  <LangVersion>10</LangVersion>
+	  <LangVersion>11</LangVersion>
 	  <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 

sources/NetArchTest/Predicate.cs

@@ -232,5 +232,25 @@ public PredicateList MeetCustomRule(Func<TypeDefinition, bool> rule)
             AddFunctionCall(x => FunctionDelegates.MeetCustomRule(x, rule, true));
             return CreatePredicateList();
         }
+
+        /// <summary>
+        /// Selects types that meet a custom rule.
+        /// </summary>
+        /// <param name="rule">An instance of the custom rule.</param>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public PredicateList MeetCustomRule(ICustomRule2 rule)
+        {
+            AddFunctionCall(x => FunctionDelegates.MeetCustomRule(x, rule, true));
+            return CreatePredicateList();
+        }
+        /// <summary>
+        /// Selects types that meet a custom rule.
+        /// </summary>        
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public PredicateList MeetCustomRule(Func<TypeDefinition, CustomRuleResult> rule)
+        {
+            AddFunctionCall(x => FunctionDelegates.MeetCustomRule(x, rule, true));
+            return CreatePredicateList();
+        }
     }
 }

tests/NetArchTest.Rules.UnitTests/PredicateTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Reflection;
+using Mono.Cecil;
 using NetArchTest.CrossAssemblyTest.A;
 using NetArchTest.CrossAssemblyTest.B;
 using NetArchTest.Rules;
@@ -284,5 +285,29 @@ public void MeetCustomRule()
             // The custom rule was executed at least once
             Assert.True(rule.TestMethodCalled);
         }
+
+        [Fact(DisplayName = "MeetCustomRule2")]
+        public void MeetCustomRule2()
+        {
+            // Create a custom rule that selects "ClassA1"
+            Func <TypeDefinition, CustomRuleResult> rule = t => new CustomRuleResult(t.Name.Equals("ClassA3", StringComparison.InvariantCultureIgnoreCase), "yup");
+
+            // Use the custom rule
+            var result = fixture.Types
+                .That()
+                .MeetCustomRule(rule)
+                .GetTypes();
+
+
+            // ClassA1 has been returned
+            Assert.Single(result);
+
+            var first = result.First();
+
+            Assert.Equal<Type>(typeof(ClassA3), first.ReflectionType);
+            Assert.Equal("yup", first.Explanation);
+
+
+        }
     }
 }