The Big Bang

Author: NeVeSpl

src/NetArchTest.Rules/Assemblies/IType.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace NetArchTest.Rules.Assemblies
+{
+    internal interface ITypes
+    {
+        IEnumerable<TypeSpec> Failing { get; }
+        IEnumerable<TypeSpec> Passing { get; }
+    }
+
+
+    internal sealed class TypesImpl : ITypes
+    {
+        public IEnumerable<TypeSpec> Failing { get; }
+        public IEnumerable<TypeSpec> Passing { get; }
+
+
+
+    }
+}

src/NetArchTest.Rules/Assemblies/ITypes.cs

@@ -15,7 +15,7 @@ internal sealed class TypeSource
 
 
 
-        public static IEnumerable<IType> FromAssemblies(IEnumerable<Assembly> assemblies, IEnumerable<string> searchDirectories = null)
+        public static IEnumerable<TypeSpec> FromAssemblies(IEnumerable<Assembly> assemblies, IEnumerable<string> searchDirectories = null)
         {
             foreach (var assembly in assemblies)
             {
@@ -30,7 +30,7 @@ public static IEnumerable<IType> FromAssemblies(IEnumerable<Assembly> assemblies
                 }
             }
         }
-        public static IEnumerable<IType> FromFiles(IEnumerable<string> fileNames, IEnumerable<string> searchDirectories = null)
+        public static IEnumerable<TypeSpec> FromFiles(IEnumerable<string> fileNames, IEnumerable<string> searchDirectories = null)
         {
             foreach (var fileName in fileNames)
             {
@@ -41,7 +41,7 @@ public static IEnumerable<IType> FromFiles(IEnumerable<string> fileNames, IEnume
             }
         }
 
-        private static IEnumerable<IType> ReadTypes(string assemblyLocation, IEnumerable<string> searchDirectories = null)
+        private static IEnumerable<TypeSpec> ReadTypes(string assemblyLocation, IEnumerable<string> searchDirectories = null)
         {
             ReaderParameters readerParameters = null;
 
@@ -87,7 +87,7 @@ private static AssemblyDefinition ReadAssemblyDefinition(string path, ReaderPara
                 return null;
             }
         }
-        private static IEnumerable<IType> GetAllTypes(IEnumerable<TypeDefinition> types)
+        private static IEnumerable<TypeSpec> GetAllTypes(IEnumerable<TypeDefinition> types)
         {
             foreach (var type in types)
             {
@@ -96,7 +96,7 @@ private static IEnumerable<IType> GetAllTypes(IEnumerable<TypeDefinition> types)
                     continue;
                 }
 
-                yield return new TypeImpl(type);
+                yield return new TypeSpec(type);
 
                 if (type.NestedTypes?.Any() == true)
                 {

src/NetArchTest.Rules/Assemblies/TypeSource.cs

@@ -0,0 +1,23 @@
+using Mono.Cecil;
+
+namespace NetArchTest.Rules.Assemblies
+{
+    internal sealed class TypeSpec
+    {
+        public TypeDefinition Definition { get; }
+        public string FullName => Definition.FullName;
+        internal bool IsSelected { get; set;  }
+
+
+        public TypeSpec(TypeDefinition definition)
+        {
+            Definition = definition;
+        }
+
+
+        public static implicit operator TypeDefinition(TypeSpec type)
+        {
+            return type.Definition;
+        }
+    }
+}

src/NetArchTest.Rules/Assemblies/TypeSpec.cs

@@ -1,43 +1,30 @@
-namespace NetArchTest.Rules
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using Mono.Cecil;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NetArchTest.Rules.Assemblies;
 
+namespace NetArchTest.Rules
+{
     /// <summary>
     /// A set of conditions that can be applied to a list of types.
     /// </summary>
-    public sealed class Conditions
-    {
-        /// <summary> A list of types that conditions can be applied to. </summary>
-        private readonly IEnumerable<TypeDefinition> _types;
-
-        /// <summary> The sequence of conditions that is applied to the type of list. </summary>
+    public sealed class Condition
+    {        
+        private readonly IEnumerable<TypeSpec> _types;     
         private readonly FunctionSequence _sequence;
 
-        /// <summary> Determines the polarity of the selection, i.e. "should" or "should not". </summary>
-        private readonly bool _should;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="Conditions"/> class.
-        /// </summary>
-        internal Conditions(IEnumerable<TypeDefinition> types, bool should)
+        /// <summary> Determines the polarity of the selection, i.e. "should" or "should not". </summary>
+        private readonly bool _should;       
+      
+       
+        internal Condition(IEnumerable<TypeSpec> types, bool should, FunctionSequence calls = null)
         {
-            _types = types.ToList();
+            _types = types;
             _should = should;
-            _sequence = new FunctionSequence();
+            _sequence = calls ?? new FunctionSequence();
         }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="Conditions"/> class.
-        /// </summary>
-        internal Conditions(IEnumerable<TypeDefinition> types, bool should, FunctionSequence calls)
-        {
-            _types = types.ToList();
-            _should = should;
-            _sequence = calls;
-        }
 
         /// <summary>
         /// Selects types that have a specific name.
@@ -712,4 +699,4 @@ public ConditionList MeetCustomRule(ICustomRule rule)
             return new ConditionList(_types, _should, _sequence);
         }
     }
-}
+}

src/NetArchTest.Rules/Conditions.cs src/NetArchTest.Rules/Condition.cssrc/NetArchTest.Rules/Conditions.cs renamed to src/NetArchTest.Rules/Condition.cs

@@ -1,51 +1,50 @@
-namespace NetArchTest.Rules
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using NetArchTest.Rules.Extensions;
-    using Mono.Cecil;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NetArchTest.Rules.Assemblies;
+using NetArchTest.Rules.Extensions;
 
+namespace NetArchTest.Rules
+{
     /// <summary>
     /// A set of conditions and types that have have conjunctions (i.e. "and", "or") and executors (i.e. Types(), GetResult()) applied to them.
     /// </summary>
     public sealed class ConditionList
-    {
-        /// <summary> A list of types that conditions can be applied to. </summary>
-        private readonly IEnumerable<TypeDefinition> _types;
-
-        /// <summary> The sequence of conditions that is applied to the type of list. </summary>
+    {        
+        private readonly IEnumerable<TypeSpec> _types;
         private readonly FunctionSequence _sequence;
 
         /// <summary> Determines the polarity of the selection, i.e. "should" or "should not". </summary>
         private readonly bool _should;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ConditionList"/> class.
-        /// </summary>
-        internal ConditionList(IEnumerable<TypeDefinition> classes, bool should, FunctionSequence sequence)
+       
+        internal ConditionList(IEnumerable<TypeSpec> classes, bool should, FunctionSequence sequence)
         {
-            _types = classes.ToList();
+            _types = classes;
             _should = should;
             _sequence = sequence;
         }
 
+
         /// <summary>
         /// Returns an indication of whether all the selected types satisfy the conditions.
         /// </summary>
         /// <returns>An indication of whether the conditions are true, along with a list of types failing the check if they are not.</returns>
         public TestResult GetResult()
         {
             bool success;
+
+            var passingTypes = _sequence.Execute(_types);
+
             if (_should)
             {
                 // All the classes should meet the condition
-                success = (_sequence.Execute(_types).Count() == _types.Count());
+                success = (passingTypes.Count() == _types.Count());
             }
             else
             {
                 // No classes should meet the condition
-                success = (!_sequence.Execute(_types).Any());
+                success = (passingTypes.Count() == 0);
             }
 
             if (success)
@@ -54,47 +53,38 @@ public TestResult GetResult()
             }
 
             // If we've failed, get a collection of failing types so these can be reported in a failing test.
-            var failedTypes = _sequence.Execute(_types, selected: !_should).ToList();
+            var failedTypes = _sequence.ExecuteExtended(_types, selected: !_should);
             return TestResult.Failure(failedTypes);
         }
 
-        /// <summary>
-        /// Returns the number of types that satisfy the conditions.
-        /// </summary>
-        /// <returns>A list of types.</returns>
-        public int Count()
-        {
-            return _sequence.Execute(_types).Count();
-        }
-
         /// <summary>
         /// Returns the list of types that satisfy the conditions.
         /// </summary>
         /// <returns>A list of types.</returns>
         public IEnumerable<Type> GetTypes()
         {
-            return _sequence.Execute(_types).Select(t => t.ToType());
+            return _sequence.Execute(_types).Select(t => t.Definition.ToType());
         }
 
         /// <summary>
         /// Specifies that any subsequent condition should be treated as an "and" condition.
         /// </summary>
         /// <returns>An set of conditions that can be applied to a list of classes.</returns>
         /// <remarks>And() has higher priority than Or() and it is computed first.</remarks>
-        public Conditions And()
+        public Condition And()
         {
-            return new Conditions(_types, _should, _sequence);
+            return new Condition(_types, _should, _sequence);
         }
 
         /// <summary>
         /// Specifies that any subsequent conditions should be treated as part of an "or" condition.
         /// </summary>
         /// <returns>An set of conditions that can be applied to a list of classes.</returns>
-        public Conditions Or()
+        public Condition Or()
         {
             // Create a new group of functions - this has the effect of creating an "or" condition
             _sequence.CreateGroup();
-            return new Conditions(_types, _should, _sequence);
+            return new Condition(_types, _should, _sequence);
         }
     }
-}
+}

src/NetArchTest.Rules/ConditionList.cs

@@ -4,6 +4,7 @@
     using System.Collections.Generic;
     using System.Linq;
     using Mono.Cecil;
+    using NetArchTest.Rules.Assemblies;
     using NetArchTest.Rules.Dependencies.DataStructures;
 
 
@@ -18,7 +19,7 @@ internal class DependencySearch
         /// <param name="input">The set of type definitions to search.</param>
         /// <param name="dependencies">The set of dependencies to look for.</param>
         /// <returns>A list of found types.</returns>
-        public IReadOnlyList<TypeDefinition> FindTypesThatHaveDependencyOnAny(IEnumerable<TypeDefinition> input, IEnumerable<string> dependencies)
+        public IReadOnlyList<TypeSpec> FindTypesThatHaveDependencyOnAny(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {  
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.HaveDependencyOnAny, dependencies, true);           
         }
@@ -29,7 +30,7 @@ public IReadOnlyList<TypeDefinition> FindTypesThatHaveDependencyOnAny(IEnumerabl
         /// <param name="input">The set of type definitions to search.</param>
         /// <param name="dependencies">The set of dependencies to look for.</param>
         /// <returns>A list of found types.</returns>
-        public IReadOnlyList<TypeDefinition> FindTypesThatHaveDependencyOnAll(IEnumerable<TypeDefinition> input, IEnumerable<string> dependencies)
+        public IReadOnlyList<TypeSpec> FindTypesThatHaveDependencyOnAll(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {  
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.HaveDependencyOnAll, dependencies, true);         
         }
@@ -40,7 +41,7 @@ public IReadOnlyList<TypeDefinition> FindTypesThatHaveDependencyOnAll(IEnumerabl
         /// <param name="input">The set of type definitions to search.</param>
         /// <param name="dependencies">The set of dependencies to look for.</param>
         /// <returns>A list of found types.</returns>
-        public IReadOnlyList<TypeDefinition> FindTypesThatOnlyHaveDependenciesOnAnyOrNone(IEnumerable<TypeDefinition> input, IEnumerable<string> dependencies)
+        public IReadOnlyList<TypeSpec> FindTypesThatOnlyHaveDependenciesOnAnyOrNone(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {           
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.OnlyHaveDependenciesOnAnyOrNone, dependencies, false);
         }
@@ -51,7 +52,7 @@ public IReadOnlyList<TypeDefinition> FindTypesThatOnlyHaveDependenciesOnAnyOrNon
         /// <param name="input">The set of type definitions to search.</param>
         /// <param name="dependencies">The set of dependencies to look for.</param>
         /// <returns>A list of found types.</returns>
-        public IReadOnlyList<TypeDefinition> FindTypesThatOnlyHaveDependenciesOnAny(IEnumerable<TypeDefinition> input, IEnumerable<string> dependencies)
+        public IReadOnlyList<TypeSpec> FindTypesThatOnlyHaveDependenciesOnAny(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.OnlyHaveDependenciesOnAny, dependencies, false);
         }
@@ -62,14 +63,14 @@ public IReadOnlyList<TypeDefinition> FindTypesThatOnlyHaveDependenciesOnAny(IEnu
         /// <param name="input">The set of type definitions to search.</param>
         /// <param name="dependencies">The set of dependencies to look for.</param>
         /// <returns>A list of found types.</returns>
-        public IReadOnlyList<TypeDefinition> FindTypesThatOnlyOnlyHaveDependenciesOnAll(IEnumerable<TypeDefinition> input, IEnumerable<string> dependencies)
+        public IReadOnlyList<TypeSpec> FindTypesThatOnlyOnlyHaveDependenciesOnAll(IEnumerable<TypeSpec> input, IEnumerable<string> dependencies)
         {
             return FindTypes(input, TypeDefinitionCheckingResult.SearchType.OnlyHaveDependenciesOnAll, dependencies, false);
         }
 
-        private List<TypeDefinition> FindTypes(IEnumerable<TypeDefinition> input, TypeDefinitionCheckingResult.SearchType searchType, IEnumerable<string> dependencies, bool serachForDependencyInFieldConstant)
+        private List<TypeSpec> FindTypes(IEnumerable<TypeSpec> input, TypeDefinitionCheckingResult.SearchType searchType, IEnumerable<string> dependencies, bool serachForDependencyInFieldConstant)
         {
-            var output = new List<TypeDefinition>();
+            var output = new List<TypeSpec>();
             var searchTree = new CachedNamespaceTree(dependencies);
 
             foreach (var type in input)