added Fluent Syntax for classes that are records

Author: francisgauthier1

ArchUnitNET/Domain/Class.cs

@@ -16,18 +16,20 @@ public class Class : IType
     {
         private IType Type { get; }
 
-        public Class(IType type, bool? isAbstract = null, bool? isSealed = null)
+        public Class(IType type, bool? isAbstract = null, bool? isSealed = null, bool? isRecord = null)
         {
             Type = type;
             IsAbstract = isAbstract;
             IsSealed = isSealed;
+            IsRecord = isRecord;
         }
 
         public Class(Class @class)
         {
             Type = @class.Type;
             IsAbstract = @class.IsAbstract;
             IsSealed = @class.IsSealed;
+            IsRecord = @class.IsRecord;
         }
 
         public IEnumerable<ITypeDependency> DependenciesIncludingInherited =>
@@ -47,6 +49,7 @@ public Class(Class @class)
         public IEnumerable<MethodMember> Constructors => Type.GetConstructors();
         public bool? IsAbstract { get; }
         public bool? IsSealed { get; }
+        public bool? IsRecord { get; }
 
         public IEnumerable<Class> InheritedClasses =>
             BaseClass == null
@@ -86,7 +89,8 @@ private bool Equals(Class other)
         {
             return Equals(Type, other.Type)
                 && Equals(IsAbstract, other.IsAbstract)
-                && Equals(IsSealed, other.IsSealed);
+                && Equals(IsSealed, other.IsSealed)
+                && Equals(IsRecord, other.IsRecord);
         }
 
         public override bool Equals(object obj)
@@ -111,6 +115,7 @@ public override int GetHashCode()
                 var hashCode = Type != null ? Type.GetHashCode() : 0;
                 hashCode = (hashCode * 397) ^ IsAbstract.GetHashCode();
                 hashCode = (hashCode * 397) ^ IsSealed.GetHashCode();
+                hashCode = (hashCode * 397) ^ IsRecord.GetHashCode();
                 return hashCode;
             }
         }

ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/ClassConditionsDefinition.cs

@@ -30,6 +30,15 @@ public static ICondition<Class> BeSealed()
             );
         }
 
+        public static ICondition<Class> BeRecord()
+        {
+            return new SimpleCondition<Class>(
+                cls => !cls.IsRecord.HasValue || cls.IsRecord.Value,
+                "be record",
+                "is not record"
+            );
+        }
+
         public static ICondition<Class> BeImmutable()
         {
             return new SimpleCondition<Class>(
@@ -61,6 +70,14 @@ public static ICondition<Class> NotBeSealed()
                 "is sealed"
             );
         }
+        public static ICondition<Class> NotBeRecord()
+        {
+            return new SimpleCondition<Class>(
+                cls => !cls.IsRecord.HasValue || !cls.IsRecord.Value,
+                "not be record",
+                "is record"
+            );
+        }
 
         public static ICondition<Class> NotBeImmutable()
         {

ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/ClassPredicatesDefinition.cs

@@ -28,6 +28,14 @@ public static IPredicate<Class> AreSealed()
             );
         }
 
+        public static IPredicate<Class> AreRecord()
+        {
+            return new SimplePredicate<Class>(
+                cls => !cls.IsRecord.HasValue || cls.IsRecord.Value,
+                "are record"
+            );
+        }
+
         public static IPredicate<Class> AreImmutable()
         {
             return new SimplePredicate<Class>(
@@ -56,6 +64,14 @@ public static IPredicate<Class> AreNotSealed()
             );
         }
 
+        public static IPredicate<Class> AreNotRecord()
+        {
+            return new SimplePredicate<Class>(
+                cls => !cls.IsRecord.HasValue || !cls.IsRecord.Value,
+                "are not record"
+            );
+        }
+
         public static IPredicate<Class> AreNotImmutable()
         {
             return new SimplePredicate<Class>(

ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/ClassesShould.cs

@@ -27,6 +27,12 @@ public ClassesShouldConjunction BeSealed()
             return new ClassesShouldConjunction(_ruleCreator);
         }
 
+        public ClassesShouldConjunction BeRecord()
+        {
+            _ruleCreator.AddCondition(ClassConditionsDefinition.BeRecord());
+            return new ClassesShouldConjunction(_ruleCreator);
+        }
+
         public ClassesShouldConjunction BeImmutable()
         {
             _ruleCreator.AddCondition(ClassConditionsDefinition.BeImmutable());
@@ -48,6 +54,12 @@ public ClassesShouldConjunction NotBeSealed()
             return new ClassesShouldConjunction(_ruleCreator);
         }
 
+        public ClassesShouldConjunction NotBeRecord()
+        {
+            _ruleCreator.AddCondition(ClassConditionsDefinition.NotBeRecord());
+            return new ClassesShouldConjunction(_ruleCreator);
+        }
+
         public ClassesShouldConjunction NotBeImmutable()
         {
             _ruleCreator.AddCondition(ClassConditionsDefinition.NotBeImmutable());

ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/GivenClassesThat.cs

@@ -27,6 +27,12 @@ public GivenClassesConjunction AreSealed()
             return new GivenClassesConjunction(_ruleCreator);
         }
 
+        public GivenClassesConjunction AreRecord()
+        {
+            _ruleCreator.AddPredicate(ClassPredicatesDefinition.AreRecord());
+            return new GivenClassesConjunction(_ruleCreator);
+        }
+
         public GivenClassesConjunction AreImmutable()
         {
             _ruleCreator.AddPredicate(ClassPredicatesDefinition.AreImmutable());
@@ -48,6 +54,12 @@ public GivenClassesConjunction AreNotSealed()
             return new GivenClassesConjunction(_ruleCreator);
         }
 
+        public GivenClassesConjunction AreNotRecord()
+        {
+            _ruleCreator.AddPredicate(ClassPredicatesDefinition.AreNotRecord());
+            return new GivenClassesConjunction(_ruleCreator);
+        }
+
         public GivenClassesConjunction AreNotImmutable()
         {
             _ruleCreator.AddPredicate(ClassPredicatesDefinition.AreNotImmutable());

ArchUnitNET/Loader/MonoCecilTypeExtensions.cs

@@ -6,9 +6,11 @@
 //
 
 using System;
+using System.Linq;
 using ArchUnitNET.Domain;
 using JetBrains.Annotations;
 using Mono.Cecil;
+using Mono.Cecil.Rocks;
 using static ArchUnitNET.Domain.Visibility;
 using GenericParameter = Mono.Cecil.GenericParameter;
 
@@ -102,5 +104,10 @@ internal static Visibility GetVisibility([CanBeNull] this TypeDefinition typeDef
                 "The provided type definition seems to have no visibility."
             );
         }
+
+        internal static bool IsRecord(this TypeDefinition typeDefinition)
+        {
+            return typeDefinition.IsClass && typeDefinition.GetMethods().Any(x => x.Name == "<Clone>$");
+        }
     }
 }

ArchUnitNET/Loader/TypeFactory.cs

@@ -353,7 +353,7 @@ bool isStub
             else
             {
                 createdTypeInstance = new TypeInstance<Class>(
-                    new Class(type, typeDefinition.IsAbstract, typeDefinition.IsSealed)
+                    new Class(type, typeDefinition.IsAbstract, typeDefinition.IsSealed, typeDefinition.IsRecord())
                 );
             }
 

ArchUnitNETTests/Fluent/Syntax/Elements/ClassSyntaxElementsTests.cs

@@ -230,6 +230,39 @@ public void AreImmutableTest()
             Assert.True(notImmutableClassesAreNotImmutabled.HasNoViolations(Architecture));
         }
 
+        [Fact]
+        public void AreRecordTest()
+        {
+            var recordsAreRecord = Classes()
+                .That()
+                .AreRecord()
+                .Should()
+                .BeRecord();
+
+            var recordsAreNotRecord = Classes()
+                .That()
+                .AreRecord()
+                .Should()
+                .NotBeRecord();
+
+            var notRecordsAreRecord = Classes()
+                .That()
+                .AreNotRecord()
+                .Should()
+                .BeRecord();
+
+            var notRecordsAreNotRecord = Classes()
+                .That()
+                .AreNotRecord()
+                .Should()
+                .NotBeRecord();
+
+            Assert.True(recordsAreRecord.HasNoViolations(Architecture));
+            Assert.False(recordsAreNotRecord.HasNoViolations(Architecture));
+            Assert.False(notRecordsAreRecord.HasNoViolations(Architecture));
+            Assert.True(notRecordsAreNotRecord.HasNoViolations(Architecture));
+        }
+
         private record ImmutableRecord(string Property, string AnotherProperty);
 
         private class ImmutableClass