Refactor Object Syntax Elements

ArchUnitNET/Domain/Extensions/EnumerableExtensions.cs

@@ -21,5 +21,26 @@ public static bool IsNullOrEmpty<T>(this IEnumerable<T> source)
         {
             return source == null || !source.Any();
         }
+
+        public static string FormatDescription<T>(
+            this IEnumerable<T> source,
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription,
+            Func<T, string> elementDescription = null
+        )
+        {
+            var list = source as IList<T> ?? source.ToList();
+            elementDescription = elementDescription ?? (element => $"\"{element}\"");
+            switch (list.Count)
+            {
+                case 0:
+                    return emptyDescription;
+                case 1:
+                    return $"{singleDescription} {string.Join(" and ", list.Select(elementDescription))}";
+                default:
+                    return $"{multipleDescription} {string.Join(" and ", list.Select(elementDescription))}";
+            }
+        }
     }
 }

ArchUnitNET/Domain/Extensions/NamingExtensions.cs

@@ -9,6 +9,16 @@ namespace ArchUnitNET.Domain.Extensions
 {
     public static class NamingExtensions
     {
+        public static bool NameEquals(this IHasName cls, string name)
+        {
+            return string.Equals(cls.Name, name, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public static bool NameMatches(this IHasName cls, string pattern)
+        {
+            return pattern != null && Regex.IsMatch(cls.Name, pattern);
+        }
+
         public static bool NameEndsWith(
             this IHasName cls,
             string pattern,
@@ -36,31 +46,79 @@ public static bool NameContains(
             return cls.Name.IndexOf(pattern, stringComparison) >= 0;
         }
 
-        public static bool NameEquals(this IHasName cls, string name)
+        public static bool FullNameEquals(this IHasName cls, string fullName)
         {
-            return string.Equals(cls.Name, name, StringComparison.OrdinalIgnoreCase);
+            return string.Equals(cls.FullName, fullName, StringComparison.OrdinalIgnoreCase);
         }
 
-        public static bool NameMatches(this IHasName cls, string pattern)
+        public static bool FullNameMatches(this IHasName cls, string pattern)
         {
-            return pattern != null && Regex.IsMatch(cls.Name, pattern);
+            return pattern != null && Regex.IsMatch(cls.FullName, pattern);
         }
 
-        public static bool FullNameEquals(this IHasName cls, string fullName)
+        public static bool FullNameEndsWith(this IHasName cls, string pattern)
         {
-            return string.Equals(cls.FullName, fullName, StringComparison.OrdinalIgnoreCase);
+            return cls.FullName.EndsWith(pattern, StringComparison.OrdinalIgnoreCase);
         }
 
-        public static bool FullNameMatches(this IHasName cls, string pattern)
+        public static bool FullNameStartsWith(this IHasName cls, string pattern)
         {
-            return pattern != null && Regex.IsMatch(cls.FullName, pattern);
+            return cls.FullName.StartsWith(pattern, StringComparison.OrdinalIgnoreCase);
         }
 
         public static bool FullNameContains(this IHasName cls, string pattern)
         {
             return pattern != null && cls.FullName.ToLower().Contains(pattern.ToLower());
         }
 
+        public static bool AssemblyQualifiedNameEquals(
+            this IHasAssemblyQualifiedName cls,
+            string assemblyQualifiedName
+        )
+        {
+            return string.Equals(
+                cls.AssemblyQualifiedName,
+                assemblyQualifiedName,
+                StringComparison.OrdinalIgnoreCase
+            );
+        }
+
+        public static bool AssemblyQualifiedNameMatches(
+            this IHasAssemblyQualifiedName cls,
+            string pattern
+        )
+        {
+            return pattern != null && Regex.IsMatch(cls.AssemblyQualifiedName, pattern);
+        }
+
+        public static bool AssemblyQualifiedNameEndsWith(
+            this IHasAssemblyQualifiedName cls,
+            string pattern
+        )
+        {
+            return cls.AssemblyQualifiedName.EndsWith(pattern, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public static bool AssemblyQualifiedNameStartsWith(
+            this IHasAssemblyQualifiedName cls,
+            string pattern
+        )
+        {
+            return cls.AssemblyQualifiedName.StartsWith(
+                pattern,
+                StringComparison.OrdinalIgnoreCase
+            );
+        }
+
+        public static bool AssemblyQualifiedNameContains(
+            this IHasAssemblyQualifiedName cls,
+            string pattern
+        )
+        {
+            return pattern != null
+                && cls.AssemblyQualifiedName.ToLower().Contains(pattern.ToLower());
+        }
+
         [NotNull]
         public static IEnumerable<TType> WhereNameIs<TType>(
             this IEnumerable<TType> source,

ArchUnitNET/Domain/IObjectProvider.cs

@@ -5,5 +5,11 @@ namespace ArchUnitNET.Domain
     public interface IObjectProvider<out T> : IHasDescription
     {
         IEnumerable<T> GetObjects(Architecture architecture);
+
+        string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        );
     }
 }

ArchUnitNET/Fluent/ObjectProvider.cs → ArchUnitNET/Domain/ObjectProvider.cs

@@ -4,7 +4,7 @@
 
 namespace ArchUnitNET.Fluent
 {
-    public class ObjectProvider<T> : ISizedObjectProvider<T>
+    internal class ObjectProvider<T> : ISizedObjectProvider<T>
         where T : ICanBeAnalyzed
     {
         private readonly List<T> _objects;
@@ -20,16 +20,32 @@ public ObjectProvider(IEnumerable<T> objects)
 
         public string Description { get; }
 
-        public int Count => _objects.Count();
+        public int Count => _objects.Count;
 
         public IEnumerable<T> GetObjects(Architecture architecture)
         {
             return _objects;
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            switch (Count)
+            {
+                case 0:
+                    return emptyDescription;
+                case 1:
+                    return $"{singleDescription} {Description}";
+            }
+            return $"{multipleDescription} {Description}";
+        }
+
         private bool Equals(ObjectProvider<T> other)
         {
-            return string.Equals(Description, other.Description);
+            return _objects.SequenceEqual(other._objects);
         }
 
         public override bool Equals(object obj)
@@ -49,7 +65,12 @@ public override bool Equals(object obj)
 
         public override int GetHashCode()
         {
-            return Description != null ? Description.GetHashCode() : 0;
+            return _objects != null
+                ? _objects.Aggregate(
+                    0,
+                    (current, obj) => (current * 397) ^ (obj?.GetHashCode() ?? 0)
+                )
+                : 0;
         }
     }
 }

ArchUnitNET/Fluent/SystemTypeObjectProvider.cs → ArchUnitNET/Domain/SystemTypeObjectProvider.cs

@@ -6,7 +6,7 @@
 
 namespace ArchUnitNET.Fluent
 {
-    public class SystemTypeObjectProvider<T> : ISizedObjectProvider<T>
+    internal class SystemTypeObjectProvider<T> : ISizedObjectProvider<T>
         where T : IType
     {
         private readonly List<Type> _types;
@@ -37,9 +37,25 @@ public IEnumerable<T> GetObjects(Architecture architecture)
                 );
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            switch (Count)
+            {
+                case 0:
+                    return emptyDescription;
+                case 1:
+                    return $"{singleDescription} {Description}";
+            }
+            return $"{multipleDescription} {Description}";
+        }
+
         private bool Equals(SystemTypeObjectProvider<T> other)
         {
-            return string.Equals(Description, other.Description);
+            return _types.SequenceEqual(other._types);
         }
 
         public override bool Equals(object obj)
@@ -59,7 +75,12 @@ public override bool Equals(object obj)
 
         public override int GetHashCode()
         {
-            return Description != null ? Description.GetHashCode() : 0;
+            return _types != null
+                ? _types.Aggregate(
+                    0,
+                    (current, type) => (current * 397) ^ (type?.GetHashCode() ?? 0)
+                )
+                : 0;
         }
     }
 }

ArchUnitNET/Fluent/BasicObjectProvider.cs

@@ -22,6 +22,15 @@ public IEnumerable<T> GetObjects(Architecture architecture)
             return architecture.GetOrCreateObjects(this, _objects);
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            return $"{multipleDescription} {Description}";
+        }
+
         public override string ToString()
         {
             return Description;

ArchUnitNET/Fluent/Slices/GivenSlices.cs

@@ -24,5 +24,14 @@ public IEnumerable<Slice> GetObjects(Architecture architecture)
         {
             return _ruleCreator.GetSlices(architecture);
         }
+
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            return $"{multipleDescription} {Description}";
+        }
     }
 }

ArchUnitNET/Fluent/Syntax/Elements/GivenObjects.cs

@@ -30,6 +30,15 @@ public IEnumerable<TRuleType> GetObjects(Architecture architecture)
             }
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            return $"{multipleDescription} {Description}";
+        }
+
         public TRuleTypeThat That()
         {
             return Create<TRuleTypeThat, TRuleType>(_ruleCreator);

ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsConjunctionWithDescription.cs

@@ -32,6 +32,15 @@ public IEnumerable<TRuleType> GetObjects(Architecture architecture)
             }
         }
 
+        public string FormatDescription(
+            string emptyDescription,
+            string singleDescription,
+            string multipleDescription
+        )
+        {
+            return $"{multipleDescription} {Description}";
+        }
+
         public TGivenRuleTypeThat And()
         {
             _ruleCreator.AddPredicateConjunction(LogicalConjunctionDefinition.And);