The one with slices

Author: NeVeSpl

src/NetArchTest.Rules/Assemblies/TypeSpec.cs

@@ -15,6 +15,13 @@ public TypeSpec(TypeDefinition definition)
         }
 
 
+
+        public TypeWrapper CreateWrapper()
+        {
+            return new TypeWrapper(Definition);
+        }
+
+
         public static implicit operator TypeDefinition(TypeSpec type)
         {
             return type.Definition;

src/NetArchTest.Rules/Assemblies/TypeWrapper.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Diagnostics;
+using Mono.Cecil;
+using NetArchTest.Rules.Extensions;
+
+namespace NetArchTest.Rules.Assemblies
+{
+    /// <summary>
+    /// Type wrapper.
+    /// </summary>
+    [DebuggerDisplay("{FullName}")]
+    internal sealed class TypeWrapper : IType
+    {
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        private readonly TypeDefinition _monoTypeDefinition;
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        private readonly Lazy<Type> _type;
+
+        internal TypeWrapper(TypeDefinition monoTypeDefinition)
+        {
+            _monoTypeDefinition = monoTypeDefinition;
+            _type = new Lazy<Type>(() =>
+            {
+                Type type = null;
+                try
+                {
+                    type = _monoTypeDefinition.ToType();
+                }
+                catch { }
+                return type;
+            });
+        }
+
+        /// <summary>
+        /// System.Type
+        /// </summary>
+        /// <remarks>
+        /// This property may be null if the test project does not have a direct dependency on the type.
+        /// </remarks>
+        public Type Type { get => _type.Value; }
+
+        /// <summary>
+        /// FullName of the type
+        /// </summary>       
+        public string FullName { get => _monoTypeDefinition.FullName; }
+
+        /// <summary>
+        /// Name of the type
+        /// </summary>       
+        public string Name { get => _monoTypeDefinition.Name; }
+
+
+        public static implicit operator System.Type(TypeWrapper type)
+        {
+            return type.Type;
+        }
+    }
+}

src/NetArchTest.Rules/ConditionList.cs

@@ -61,9 +61,14 @@ public TestResult GetResult()
         /// Returns the list of types that satisfy the conditions.
         /// </summary>
         /// <returns>A list of types.</returns>
-        public IEnumerable<Type> GetTypes()
+        public IEnumerable<IType> GetTypes()
         {
-            return _sequence.Execute(_types).Select(t => t.Definition.ToType());
+            return _sequence.Execute(_types).Select(t => t.CreateWrapper());
+        }
+
+        internal IEnumerable<Type> GetNetTypes()
+        {
+            return GetTypes().Select(x => x.Type);
         }
 
         /// <summary>

src/NetArchTest.Rules/IType.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace NetArchTest.Rules
+{
+    /// <summary>
+    /// Type wrapper.
+    /// </summary>
+    public interface IType
+    { 
+        /// <summary>
+        /// System.Type
+        /// </summary>
+        /// <remarks>
+        /// This property may be null if the test project does not have a direct dependency on the type.
+        /// </remarks>
+        Type Type { get; }
+
+        /// <summary>
+        /// FullName of the type
+        /// </summary>       
+        string FullName { get; }
+
+        /// <summary>
+        /// Name of the type
+        /// </summary>       
+        string Name { get; }
+    }
+}

src/NetArchTest.Rules/Policies/PolicyResult.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using NetArchTest.Rules.Assemblies;
 
     /// <summary>
     /// A single test result for a policy.
@@ -27,7 +28,7 @@ internal PolicyResult(TestResult result, string name, string description)
         /// <summary>
         /// Gets a collection populated with a list of any types that failed the test.
         /// </summary>
-        public IEnumerable<Type> FailingTypes { get; private set; }
+        public IEnumerable<IType> FailingTypes { get; private set; }
 
         /// <summary>
         /// Gets the simple name associated with the test.

src/NetArchTest.Rules/PredicateList.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using NetArchTest.Rules.Assemblies;
 using NetArchTest.Rules.Extensions;
+using NetArchTest.Rules.Slices;
 
 namespace NetArchTest.Rules
 {
@@ -44,21 +45,31 @@ public Condition ShouldNot()
         }
 
         /// <summary>
-        /// Returns the type definitions returned by these predicate.
+        /// Allows dividing types into groups, also called slices.
         /// </summary>
-        /// <returns>A list of type definitions.</returns>
+        /// <returns></returns>
+        public SlicePredicate Slice()
+        {
+            return new SlicePredicate(GetTypeSpecifications());
+        }
+
+       
         internal IEnumerable<TypeSpec> GetTypeSpecifications()
         { 
             return _sequence.Execute(_types);
         }
+        internal IEnumerable<Type> GetNetTypes()
+        {
+            return GetTypes().Select(x => x.Type);
+        }
 
         /// <summary>
         /// Returns the types returned by these predicates.
         /// </summary>
         /// <returns>A list of types.</returns>
-        public IEnumerable<Type> GetTypes()
+        public IEnumerable<IType> GetTypes()
         {
-            return GetTypeSpecifications().Select(t => t.Definition.ToType());
+            return GetTypeSpecifications().Select(t => t.CreateWrapper());
         }
 
         /// <summary>

src/NetArchTest.Rules/Slices/Model/Filters/HaveDependenciesBetweenSlices.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using NetArchTest.Rules.Assemblies;
+using NetArchTest.Rules.Dependencies;
+
+namespace NetArchTest.Rules.Slices.Model
+{
+    internal sealed class HaveDependenciesBetweenSlices : IFilter
+    {
+        public IEnumerable<TypeTestResult> Execute(SlicedTypes slicedTypes)
+        {
+            var dependencySearch = new DependencySearch();
+            var result = new List<TypeTestResult>(slicedTypes.TypeCount);
+
+            for (int i = 0; i < slicedTypes.Slices.Count; i++)
+            {
+                var slice = slicedTypes.Slices[i];
+                var dependencies = slicedTypes.Slices.Where((_, index) => index != i).Select(x => x.Name).ToList();
+
+                var foundTypes = dependencySearch.FindTypesThatHaveDependencyOnAny(slice.Types, dependencies);
+                var lookup = new HashSet<TypeSpec>(foundTypes);
+
+                foreach (var type in slice.Types)
+                {
+                    bool isPassing = lookup.Contains(type);
+                    var typeResult = new TypeTestResult(type, isPassing);                    
+                    result.Add(typeResult);
+                }
+            }
+
+            return result;
+        }
+    }
+}

src/NetArchTest.Rules/Slices/Model/IFilter.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace NetArchTest.Rules.Slices.Model
+{
+    internal interface IFilter
+    {
+        IEnumerable<TypeTestResult> Execute(SlicedTypes slicedTypes);
+    }
+}

src/NetArchTest.Rules/Slices/Model/Slice.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using NetArchTest.Rules.Assemblies;
+
+namespace NetArchTest.Rules.Slices.Model
+{
+    internal sealed class Slice
+    {
+        public string Name { get;  }
+        public IEnumerable<TypeSpec> Types { get;  }
+
+
+        public Slice(string sliceName, List<TypeSpec> types)
+        {
+            Name = sliceName;
+            Types = types;
+        }
+    }
+}

src/NetArchTest.Rules/Slices/Model/SlicedTypes.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace NetArchTest.Rules.Slices.Model
+{
+    internal sealed class SlicedTypes
+    {
+        public int TypeCount { get; }       
+        public IReadOnlyList<Slice> Slices { get; }
+
+
+        public SlicedTypes(int typeCount, List<Slice> slices)
+        {
+            TypeCount = typeCount;
+            Slices = slices;
+        }
+    }
+}