switch to MarkPassingTypes algorithm

Author: NeVeSpl

src/NetArchTest.Rules/Extensions/IEnumerableExtensions.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace System.Collections.Generic
+{
+    internal static class IEnumerableExtensions
+    {
+        public static void ForEach<T>(this IEnumerable<T> list, Action<T> action)
+        {
+            foreach (T item in list)
+            {
+                action(item);
+            }
+        }
+    }
+}

src/NetArchTest.Rules/FunctionSequence.cs

@@ -10,16 +10,16 @@ namespace NetArchTest.Rules
     /// </summary>
     internal sealed class FunctionSequence
     {        
-        private readonly List<List<FunctionCall>> _groups;
+        private readonly List<List<IFunctionCall>> _groups;
 
 
         /// <summary>
         /// Initializes a new instance of the <see cref="FunctionSequence"/> class.
         /// </summary>
         internal FunctionSequence()
         {
-            _groups = new List<List<FunctionCall>>();
-            _groups.Add(new List<FunctionCall>());
+            _groups = new List<List<IFunctionCall>>();
+            _groups.Add(new List<IFunctionCall>());
         }
 
 
@@ -36,7 +36,7 @@ internal void AddFunctionCall<T>(FunctionDelegates.FunctionDelegate<T> method, T
         /// </summary>
         internal void CreateGroup()
         {
-            _groups.Add(new List<FunctionCall>());
+            _groups.Add(new List<IFunctionCall>());
         }
 
         /// <summary>
@@ -45,65 +45,39 @@ internal void CreateGroup()
         /// <returns>A list of types that are selected by the predicates (or not selected if optional reversing flag is passed).</returns>
         public IReadOnlyList<TypeSpec> ExecuteExtended(IEnumerable<TypeSpec> inputTypes, bool selected = true)
         {
-            var resultSets = new List<List<TypeSpec>>();
+            MarkPassingTypes(inputTypes);
 
-            // Execute each group of calls - each group represents a separate "or"
-            foreach (var group in _groups)
-            {                
-                var passingTypes = new List<TypeSpec>(inputTypes);               
-
-                // Invoke the functions iteratively - functions within a group are treated as "and" statements
-                foreach (var func in group)
-                {
-                    var funcResults = func.FunctionDelegate.DynamicInvoke(passingTypes, func.Value, func.Condition) as IEnumerable<TypeSpec>;
-                    passingTypes = funcResults.ToList();
-                }
-
-                if (passingTypes.Count > 0)
-                {
-                    resultSets.Add(passingTypes);
-                }
-            }
-
-            if (selected)
-            {
-                // Return all the types that appear in at least one of the result sets
-                return resultSets.SelectMany(list => list.Select(def => def)).Distinct().ToList();
-            }
-            else
-            {
-                // Return all the types that *do not* appear in at least one of the result sets
-                var selectedTypes = resultSets.SelectMany(list => list.Select(def => def)).Distinct().Select(t => t.Definition.FullName);
-                var notSelected = inputTypes.Where(t => !selectedTypes.Contains(t.Definition.FullName)).ToList();
-                return notSelected;
-            }
+            return inputTypes.Where(x => x.IsSelected == selected).ToList();
         }
 
         public IReadOnlyList<TypeSpec> Execute(IEnumerable<TypeSpec> inputTypes)
         {
-            var resultSets = new List<IEnumerable<TypeSpec>>();
-            
+            MarkPassingTypes(inputTypes);
+
+            return inputTypes.Where(x => x.IsSelected == true).ToList();            
+        }
+        private void MarkPassingTypes(IEnumerable<TypeSpec> inputTypes)
+        {
+            inputTypes.ForEach(x => x.IsSelected = false);
+
             foreach (var group in _groups)
             {
                 IEnumerable<TypeSpec> passingTypes = inputTypes;
-                
+
                 foreach (var func in group)
                 {
-                    var funcResults = func.FunctionDelegate.DynamicInvoke(passingTypes, func.Value, func.Condition) as IEnumerable<TypeSpec>;
+                    var funcResults = func.Execute(passingTypes);
                     passingTypes = funcResults;
                 }
 
-                resultSets.Add(passingTypes);                
+                passingTypes.ForEach(x => x.IsSelected = true);
             }
-           
-            return resultSets.SelectMany(list => list.Select(def => def)).Distinct().ToList();            
         }
 
-
         /// <summary>
         /// Represents a single function call.
         /// </summary>
-        internal class FunctionCall
+        internal class FunctionCall : IFunctionCall
         {
             /// <summary>
             /// Initializes a new instance of the <see cref="FunctionCall"/> class.
@@ -115,6 +89,13 @@ internal FunctionCall(Delegate func, object value, bool condition)
                 this.Condition = condition;
             }
 
+
+            public IEnumerable<TypeSpec> Execute(IEnumerable<TypeSpec> inputTypes)
+            {
+                return FunctionDelegate.DynamicInvoke(inputTypes, Value, Condition) as IEnumerable<TypeSpec>;
+            }
+
+
             /// <summary>
             /// A delegate for a function call.
             /// </summary>
@@ -131,5 +112,10 @@ internal FunctionCall(Delegate func, object value, bool condition)
             public bool Condition { get; private set; }
 
         }
+
+        internal interface IFunctionCall
+        {
+            IEnumerable<TypeSpec> Execute(IEnumerable<TypeSpec> inputTypes);
+        }
     }
 }

src/NetArchTest.Rules/Predicate.cs

@@ -421,7 +421,6 @@ public PredicateList AreNotNestedPrivate()
             return new PredicateList(_types, _sequence);
         }
 
-
         /// <summary>
         /// Selects types that have public scope.
         /// </summary>