Add SliceRules

ArchUnitNET/Domain/TypeDependencyComparer.cs

@@ -0,0 +1,33 @@
+//  Copyright 2019 Florian Gather <florian.gather@tngtech.com>
+// 	Copyright 2019 Paula Ruiz <paularuiz22@gmail.com>
+// 	Copyright 2019 Fritz Brandhuber <fritz.brandhuber@tngtech.com>
+// 
+// 	SPDX-License-Identifier: Apache-2.0
+// 
+
+using System.Collections.Generic;
+using ArchUnitNET.Domain.Dependencies.Types;
+
+namespace ArchUnitNET.Domain
+{
+    public class TypeDependencyComparer : IEqualityComparer<ITypeDependency>
+    {
+        public bool Equals(ITypeDependency x, ITypeDependency y)
+        {
+            if (ReferenceEquals(x, y))
+            {
+                return true;
+            }
+
+            return x != null && y != null && Equals(x.Origin, y.Origin) && Equals(x.Target, y.Target);
+        }
+
+        public int GetHashCode(ITypeDependency obj)
+        {
+            unchecked
+            {
+                return (obj.Origin.GetHashCode() * 397) ^ obj.Target.GetHashCode();
+            }
+        }
+    }
+}

ArchUnitNET/Fluent/EvaluationResult.cs

@@ -9,9 +9,9 @@
 
 namespace ArchUnitNET.Fluent
 {
-    public class EvaluationResult
+    public class EvaluationResult : IHasDescription
     {
-        public EvaluationResult([CanBeNull] ICanBeAnalyzed obj, bool passed, string description,
+        public EvaluationResult([CanBeNull] object obj, bool passed, string description,
             ICanBeEvaluated archRule, Architecture architecture)
         {
             EvaluatedObject = obj;
@@ -22,10 +22,10 @@ public EvaluationResult([CanBeNull] ICanBeAnalyzed obj, bool passed, string desc
         }
 
         public ICanBeEvaluated ArchRule { get; }
-        [CanBeNull] public ICanBeAnalyzed EvaluatedObject { get; }
+        [CanBeNull] public object EvaluatedObject { get; }
         public bool Passed { get; }
-        public string Description { get; }
         public Architecture Architecture { get; }
+        public string Description { get; }
 
         public override string ToString()
         {

ArchUnitNET/Fluent/Extensions/TypeExtensions.cs

@@ -21,7 +21,7 @@ public static class TypeExtensions
     {
         public static bool CallsMethod(this IHasDependencies type, MethodMember method)
         {
-            return type.GetCalledMethods().Contains(type);
+            return type.GetCalledMethods().Contains(method);
         }
 
         public static bool CallsMethod(this IHasDependencies type, string pattern, bool useRegularExpressions = false)

ArchUnitNET/Fluent/Slices/GivenSlices.cs

@@ -0,0 +1,33 @@
+//  Copyright 2019 Florian Gather <florian.gather@tngtech.com>
+// 	Copyright 2019 Paula Ruiz <paularuiz22@gmail.com>
+// 	Copyright 2019 Fritz Brandhuber <fritz.brandhuber@tngtech.com>
+// 
+// 	SPDX-License-Identifier: Apache-2.0
+// 
+
+using System.Collections.Generic;
+using ArchUnitNET.Domain;
+
+namespace ArchUnitNET.Fluent.Slices
+{
+    public class GivenSlices
+    {
+        private readonly SliceRuleCreator _ruleCreator;
+
+        public GivenSlices(SliceRuleCreator ruleCreator)
+        {
+            _ruleCreator = ruleCreator;
+        }
+
+        public SlicesShould Should()
+        {
+            _ruleCreator.AddToDescription("should");
+            return new SlicesShould(_ruleCreator);
+        }
+
+        public IEnumerable<Slice> GetSlices(Architecture architecture)
+        {
+            return _ruleCreator.GetSlices(architecture);
+        }
+    }
+}

ArchUnitNET/Fluent/Slices/Slice.cs

@@ -0,0 +1,29 @@
+//  Copyright 2019 Florian Gather <florian.gather@tngtech.com>
+// 	Copyright 2019 Paula Ruiz <paularuiz22@gmail.com>
+// 	Copyright 2019 Fritz Brandhuber <fritz.brandhuber@tngtech.com>
+// 
+// 	SPDX-License-Identifier: Apache-2.0
+// 
+
+using System.Collections.Generic;
+using System.Linq;
+using ArchUnitNET.Domain;
+using ArchUnitNET.Domain.Dependencies.Types;
+
+namespace ArchUnitNET.Fluent.Slices
+{
+    public class Slice : IHasDescription
+    {
+        public readonly SliceIdentifier Identifier;
+        public readonly IEnumerable<IType> Types;
+
+        public Slice(SliceIdentifier identifier, IEnumerable<IType> types)
+        {
+            Identifier = identifier;
+            Types = types;
+        }
+
+        public IEnumerable<ITypeDependency> Dependencies => Types.SelectMany(type => type.Dependencies);
+        public string Description => Identifier.Description;
+    }
+}

ArchUnitNET/Fluent/Slices/SliceAssignment.cs

@@ -0,0 +1,34 @@
+//  Copyright 2019 Florian Gather <florian.gather@tngtech.com>
+// 	Copyright 2019 Paula Ruiz <paularuiz22@gmail.com>
+// 	Copyright 2019 Fritz Brandhuber <fritz.brandhuber@tngtech.com>
+// 
+// 	SPDX-License-Identifier: Apache-2.0
+// 
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ArchUnitNET.Domain;
+
+namespace ArchUnitNET.Fluent.Slices
+{
+    public class SliceAssignment : IHasDescription
+    {
+        private readonly Func<IType, SliceIdentifier> _assignIdentifierFunc;
+
+
+        public SliceAssignment(Func<IType, SliceIdentifier> assignIdentifierFunc, string description)
+        {
+            _assignIdentifierFunc = assignIdentifierFunc;
+            Description = description;
+        }
+
+        public string Description { get; }
+
+        public IEnumerable<Slice> Apply(IEnumerable<IType> types)
+        {
+            return types.GroupBy(_assignIdentifierFunc, (identifier, enumerable) => new Slice(identifier, enumerable),
+                SliceIdentifier.Comparer);
+        }
+    }
+}

ArchUnitNET/Fluent/Slices/SliceIdentifier.cs

@@ -0,0 +1,80 @@
+//  Copyright 2019 Florian Gather <florian.gather@tngtech.com>
+// 	Copyright 2019 Paula Ruiz <paularuiz22@gmail.com>
+// 	Copyright 2019 Fritz Brandhuber <fritz.brandhuber@tngtech.com>
+// 
+// 	SPDX-License-Identifier: Apache-2.0
+// 
+
+namespace ArchUnitNET.Fluent.Slices
+{
+    public class SliceIdentifier : IHasDescription
+    {
+        public static readonly SliceIdentifierComparer Comparer = new SliceIdentifierComparer();
+        public readonly string Identifier;
+        public readonly bool Ignored;
+
+
+        private SliceIdentifier(string identifier, bool ignored)
+        {
+            Identifier = identifier;
+            Ignored = ignored;
+        }
+
+        public string Description => Identifier;
+
+        public static SliceIdentifier Of(string identifier)
+        {
+            return new SliceIdentifier(identifier, false);
+        }
+
+        public static SliceIdentifier Ignore()
+        {
+            return new SliceIdentifier("Ignored", true);
+        }
+
+        /// <summary>
+        ///     Is true when the two SliceIdentifiers belong to the same slice
+        /// </summary>
+        /// <param name="other"></param>
+        /// <returns></returns>
+        public bool CompareTo(SliceIdentifier other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return Ignored && other.Ignored || !Ignored && !other.Ignored && Identifier == other.Identifier;
+        }
+
+        private bool Equals(SliceIdentifier other)
+        {
+            return Identifier == other.Identifier && Ignored == other.Ignored;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            return obj.GetType() == GetType() && Equals((SliceIdentifier) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = 397 ^ Identifier.GetHashCode();
+                hashCode = (hashCode * 397) ^ Ignored.GetHashCode();
+                return hashCode;
+            }
+        }
+    }
+}

ArchUnitNET/Fluent/Slices/SliceIdentifierComparer.cs

@@ -0,0 +1,24 @@
+//  Copyright 2019 Florian Gather <florian.gather@tngtech.com>
+// 	Copyright 2019 Paula Ruiz <paularuiz22@gmail.com>
+// 	Copyright 2019 Fritz Brandhuber <fritz.brandhuber@tngtech.com>
+// 
+// 	SPDX-License-Identifier: Apache-2.0
+// 
+
+using System.Collections.Generic;
+
+namespace ArchUnitNET.Fluent.Slices
+{
+    public class SliceIdentifierComparer : IEqualityComparer<SliceIdentifier>
+    {
+        public bool Equals(SliceIdentifier x, SliceIdentifier y)
+        {
+            return x != null && x.CompareTo(y);
+        }
+
+        public int GetHashCode(SliceIdentifier obj)
+        {
+            return obj.GetHashCode();
+        }
+    }
+}

ArchUnitNET/Fluent/Slices/SliceRule.cs

@@ -0,0 +1,54 @@
+//  Copyright 2019 Florian Gather <florian.gather@tngtech.com>
+// 	Copyright 2019 Paula Ruiz <paularuiz22@gmail.com>
+// 	Copyright 2019 Fritz Brandhuber <fritz.brandhuber@tngtech.com>
+// 
+// 	SPDX-License-Identifier: Apache-2.0
+// 
+
+using System.Collections.Generic;
+using ArchUnitNET.Domain;
+
+namespace ArchUnitNET.Fluent.Slices
+{
+    public class SliceRule : IArchRule
+    {
+        private readonly SliceRuleCreator _ruleCreator;
+
+        public SliceRule(SliceRuleCreator ruleCreator)
+        {
+            _ruleCreator = ruleCreator;
+        }
+
+        public string Description => _ruleCreator.Description;
+
+        public bool HasNoViolations(Architecture architecture)
+        {
+            return _ruleCreator.HasNoViolations(architecture);
+        }
+
+        public IEnumerable<EvaluationResult> Evaluate(Architecture architecture)
+        {
+            return _ruleCreator.Evaluate(architecture);
+        }
+
+        public CombinedArchRuleDefinition And()
+        {
+            return new CombinedArchRuleDefinition(_ruleCreator, LogicalConjunctionDefinition.And);
+        }
+
+        public CombinedArchRuleDefinition Or()
+        {
+            return new CombinedArchRuleDefinition(_ruleCreator, LogicalConjunctionDefinition.Or);
+        }
+
+        public IArchRule And(IArchRule archRule)
+        {
+            return new CombinedArchRule(_ruleCreator, LogicalConjunctionDefinition.And, archRule);
+        }
+
+        public IArchRule Or(IArchRule archRule)
+        {
+            return new CombinedArchRule(_ruleCreator, LogicalConjunctionDefinition.Or, archRule);
+        }
+    }
+}