add rules : AreStaticless, BeStaticless

Author: NeVeSpl

sources/NetArchTest/Condition_Special.cs

@@ -47,6 +47,16 @@ public ConditionList BeStateless()
             return CreateConditionList();
         }
 
+        /// <summary>
+        /// Selects types that are staticless, they do not have static state
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList BeStaticless()
+        {
+            AddFunctionCall(x => FunctionDelegates.BeStaticless(x, true));
+            return CreateConditionList();
+        }
+
         /// <summary>
         /// Selects types according to whether they have nullable members.
         /// </summary>

sources/NetArchTest/Extensions/Mono.Cecil/TypeDefinitionExtensions.cs

@@ -167,8 +167,7 @@ public static string GetFilePath(this TypeDefinition typeDefinition)
         }
 
         public static bool IsStateless(this TypeDefinition type)
-        {
-            // Check if the type has any instance fields
+        {            
             if (type.HasFields)
             {
                 foreach (var field in type.Fields)
@@ -182,5 +181,19 @@ public static bool IsStateless(this TypeDefinition type)
             }
             return true;
         }
+        public static bool IsStaticless(this TypeDefinition type)
+        {           
+            if (type.HasFields)
+            {
+                foreach (var field in type.Fields)
+                {                    
+                    if (field.IsStatic && field.HasConstant == false)
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
     }
 }

sources/NetArchTest/Functions/FunctionDelegates_Special.cs

@@ -70,6 +70,17 @@ internal static IEnumerable<TypeSpec> BeStateless(IEnumerable<TypeSpec> input, b
                 return input.Where(c => !c.Definition.IsStateless());
             }
         }
+        internal static IEnumerable<TypeSpec> BeStaticless(IEnumerable<TypeSpec> input, bool condition)
+        {
+            if (condition)
+            {
+                return input.Where(c => c.Definition.IsStaticless());
+            }
+            else
+            {
+                return input.Where(c => !c.Definition.IsStaticless());
+            }
+        }
 
         internal static IEnumerable<TypeSpec> HaveFileNameMatchingTypeName(FunctionSequenceExecutionContext context, IEnumerable<TypeSpec> input, bool condition)
         {

sources/NetArchTest/Predicate_Special.cs

@@ -44,6 +44,16 @@ public PredicateList AreStateless()
             return CreatePredicateList();
         }
 
+        /// <summary>
+        /// Selects types that are staticless, they do not have static state
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public PredicateList AreStaticless()
+        {
+            AddFunctionCall(x => FunctionDelegates.BeStaticless(x, true));
+            return CreatePredicateList();
+        }
+
         /// <summary>
         /// Selects types that have only nullable members.
         /// </summary>

tests/NetArchTest.Rules.UnitTests/PredicateTests_Special.cs

@@ -100,6 +100,25 @@ public void AreStateless()
             Assert.Contains<Type>(typeof(StatelessClass_Prop), result);
         }
 
+        [Fact(DisplayName = "AreStaticless")]
+        public void AreStaticless()
+        {
+            var result = fixture.Types
+                .That()
+                .ResideInNamespace(namespaceof<StatelessClass_StaticField>())
+                .And()
+                .AreStaticless().GetReflectionTypes();
+
+            Assert.Equal(6, result.Count());
+    
+            Assert.Contains<Type>(typeof(StatelessClass_ConstField), result);
+            Assert.Contains<Type>(typeof(StatefulClass_Field), result);
+            Assert.Contains<Type>(typeof(StatefulRecordClass), result);
+            Assert.Contains<Type>(typeof(StatefulRecordStruct), result);
+            Assert.Contains<Type>(typeof(StatefulClass_Prop), result);
+            Assert.Contains<Type>(typeof(StatefulClass_ReadonlyField), result);
+        }
+
         [Fact(DisplayName = "OnlyHaveNullableMembers")]
         public void OnlyHaveNullableMembers()
         {