From d1e18208dae51f01d73df7cb42e12222aa4edaf8 Mon Sep 17 00:00:00 2001
From: Fritz Brandhuber <fritz.brandhuber@tngtech.com>
Date: Wed, 27 Oct 2021 16:20:53 +0200
Subject: [PATCH] small improvement to show the slices with the least
 dependencies to other slices first in the error message of a found cycle

Signed-off-by: Fritz Brandhuber <fritz.brandhuber@tngtech.com>
---
 ArchUnitNET/Fluent/Slices/SlicesShould.cs | 30 ++++++++++++++++-------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/ArchUnitNET/Fluent/Slices/SlicesShould.cs b/ArchUnitNET/Fluent/Slices/SlicesShould.cs
index eede1d2c9..392e07245 100644
--- a/ArchUnitNET/Fluent/Slices/SlicesShould.cs
+++ b/ArchUnitNET/Fluent/Slices/SlicesShould.cs
@@ -7,6 +7,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using ArchUnitNET.Domain;
 using ArchUnitNET.Fluent.Freeze;
 using StronglyConnectedComponents;
@@ -49,28 +50,39 @@ private static IEnumerable<EvaluationResult> EvaluateBeFreeOfCycles(IEnumerable<
             {
                 foreach (var cycle in cycles)
                 {
-                    var description = "Cycle found:";
+                    var depsBetweenSlices = new List<List<string>>();
                     foreach (var slice in cycle.Contents)
                     {
                         var dependencies = slice.Dependencies.ToList();
-                        foreach (var otherSlice in cycle.Contents.Except(new[] {slice}))
+                        foreach (var otherSlice in cycle.Contents.Except(new[] { slice }))
                         {
                             var depsToSlice = dependencies.Where(dependency =>
                                     otherSlice.Types.Contains(dependency.Target))
                                 .Distinct(new TypeDependencyComparer()).ToList();
                             if (depsToSlice.Any())
                             {
-                                description += "\n" + slice.Description + " -> " + otherSlice.Description;
-                                description = depsToSlice.Aggregate(description,
-                                    (current, dependency) =>
-                                        current + ("\n\t" + dependency.Origin + " -> " + dependency.Target));
+                                var depsFromThisSliceToOtherSlice = new List<string>
+                                    { slice.Description + " -> " + otherSlice.Description };
+                                depsFromThisSliceToOtherSlice.AddRange(depsToSlice.Select(dependency =>
+                                    "\t" + dependency.Origin + " -> " + dependency.Target));
+                                depsBetweenSlices.Add(depsFromThisSliceToOtherSlice);
                             }
                         }
                     }
 
-                    description += "\n";
+                    var description = new StringBuilder();
+                    description.AppendLine("Cycle found:");
+                    var orderedDeps = depsBetweenSlices.OrderBy(l => l.Count);
+                    foreach (var lines in orderedDeps)
+                    {
+                        foreach (var line in lines)
+                        {
+                            description.AppendLine(line);
+                        }
+                    }
+
                     var cycleIdentifier = new EnumerableIdentifier(cycle.Contents.Select(slice => slice.Identifier));
-                    yield return new EvaluationResult(cycle, cycleIdentifier, false, description, archRule,
+                    yield return new EvaluationResult(cycle, cycleIdentifier, false, description.ToString(), archRule,
                         architecture);
                 }
             }
@@ -98,7 +110,7 @@ private static IEnumerable<EvaluationResult> EvaluateNotDependOnEachOther(IEnume
 
             foreach (var slice in slicesList)
             {
-                var sliceDependencies = FindDependencies(slice, slicesList).Except(new[] {slice}).ToList();
+                var sliceDependencies = FindDependencies(slice, slicesList).Except(new[] { slice }).ToList();
                 var passed = !sliceDependencies.Any();
                 var description = slice.Description + " does not depend on another slice.";
                 if (!passed)