Merge pull request #380 from TNG/revert-377-feat/remove-obsolete-fluent-syntax-methods

Revert "Remove Obsolete Fluent Syntax Methods"

Author: alexanderlinne

ArchUnitNET/Domain/Extensions/AttributeExtensions.cs

@@ -5,11 +5,40 @@ namespace ArchUnitNET.Domain.Extensions
 {
     public static class AttributeExtensions
     {
+        [Obsolete(
+            "Either HasAttribute() without the useRegularExpressions parameter or HasAttributeMatching() should be used"
+        )]
+        public static bool HasAttribute(
+            this IHasAttributes a,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            return a.Attributes.Any(attribute =>
+                attribute.FullNameMatches(pattern, useRegularExpressions)
+            );
+        }
+
         public static bool HasAttribute(this IHasAttributes a, string fullName)
         {
             return a.Attributes.Any(attribute => attribute.FullNameEquals(fullName));
         }
 
+        [Obsolete(
+            "Either OnlyHasAttributes() without the useRegularExpressions parameter or OnlyHasAttributesMatching() should be used"
+        )]
+        public static bool OnlyHasAttributes(
+            this IHasAttributes a,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            return a.Attributes.IsNullOrEmpty()
+                || a.Attributes.All(attribute =>
+                    attribute.FullNameMatches(pattern, useRegularExpressions)
+                );
+        }
+
         public static bool HasAttributeMatching(this IHasAttributes a, string pattern)
         {
             return a.Attributes.Any(attribute => attribute.FullNameMatches(pattern));

ArchUnitNET/Domain/Extensions/DependencyExtensions.cs

@@ -7,6 +7,19 @@ namespace ArchUnitNET.Domain.Extensions
 {
     public static class DependencyExtensions
     {
+        [Obsolete(
+            "Either CallsMethod() without the useRegularExpressions parameter or CallsMethodMatching() should be used"
+        )]
+        public static bool CallsMethod(
+            this IHasDependencies type,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            return type.GetCalledMethods()
+                .Any(member => member.FullNameMatches(pattern, useRegularExpressions));
+        }
+
         public static bool CallsMethod(this IHasDependencies type, string fullName)
         {
             return type.GetCalledMethods().Any(member => member.FullNameEquals(fullName));
@@ -31,6 +44,19 @@ public static IEnumerable<FieldMember> GetAccessedFieldMembers(this IHasDependen
                 .Select(dependency => (FieldMember)dependency.TargetMember);
         }
 
+        [Obsolete(
+            "Either DependsOnType() without the useRegularExpressions parameter or DependsOnTypeMatching() should be used"
+        )]
+        public static bool DependsOn(
+            this IHasDependencies c,
+            string pattern,
+            bool useRegularExpressions = false
+        )
+        {
+            return c.GetTypeDependencies()
+                .Any(d => d.FullNameMatches(pattern, useRegularExpressions));
+        }
+
         public static bool DependsOnType(this IHasDependencies c, string fullName)
         {
             return c.GetTypeDependencies().Any(d => d.FullNameEquals(fullName));
@@ -41,6 +67,19 @@ public static bool DependsOnTypeMatching(this IHasDependencies c, string pattern
             return c.GetTypeDependencies().Any(d => d.FullNameMatches(pattern));
         }
 
+        [Obsolete(
+            "Either OnlyDependsOnType() without the useRegularExpressions parameter or OnlyDependsOnTypesMatching() should be used"
+        )]
+        public static bool OnlyDependsOn(
+            this IHasDependencies c,
+            string pattern,
+            bool useRegularExpressions = false
+        )
+        {
+            return c.GetTypeDependencies()
+                .All(d => d.FullNameMatches(pattern, useRegularExpressions));
+        }
+
         public static bool OnlyDependsOnType(this IHasDependencies c, string fullName)
         {
             return c.GetTypeDependencies().All(d => d.FullNameEquals(fullName));

ArchUnitNET/Domain/Extensions/MemberExtensions.cs

@@ -7,6 +7,18 @@ namespace ArchUnitNET.Domain.Extensions
 {
     public static class MemberExtensions
     {
+        [Obsolete(
+            "Either IsDeclaredIn() without the useRegularExpressions parameter or IsDeclaredInTypeMatching() should be used"
+        )]
+        public static bool IsDeclaredIn(
+            this IMember member,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            return member.DeclaringType.FullNameMatches(pattern, useRegularExpressions);
+        }
+
         public static bool IsDeclaredIn(this IMember member, string fullName)
         {
             return member.DeclaringType.FullNameEquals(fullName);
@@ -58,6 +70,22 @@ public static bool HasMethodCallDependencies(
             return member.GetMethodCallDependencies(getBackwardsDependencies).Any();
         }
 
+        [Obsolete(
+            "Either IsCalledByType() without the useRegularExpressions parameter or IsCalledByTypeMatching() should be used"
+        )]
+        public static bool IsCalledBy(
+            this MethodMember member,
+            string pattern,
+            bool useRegularExpressions = false
+        )
+        {
+            return member
+                .GetMethodCallDependencies(true)
+                .Any(dependency =>
+                    dependency.Origin.FullNameMatches(pattern, useRegularExpressions)
+                );
+        }
+
         public static bool IsCalledByType(this MethodMember member, string fullName)
         {
             return member
@@ -80,6 +108,22 @@ public static IEnumerable<IType> GetCallingTypes(this MethodMember member)
                 .Distinct();
         }
 
+        [Obsolete(
+            "Either HasDependencyInMethodBodyToType() without the useRegularExpressions parameter or HasDependencyInMethodBodyToTypeMatching() should be used"
+        )]
+        public static bool HasDependencyInMethodBodyTo(
+            this MethodMember member,
+            string pattern,
+            bool useRegularExpressions = false
+        )
+        {
+            return member
+                .GetBodyTypeMemberDependencies()
+                .Any(dependency =>
+                    dependency.Target.FullNameMatches(pattern, useRegularExpressions)
+                );
+        }
+
         public static bool HasDependencyInMethodBodyToType(
             this MethodMember member,
             string fullName

ArchUnitNET/Domain/Extensions/NamingExtensions.cs

@@ -36,6 +36,23 @@ public static bool NameContains(
             return cls.Name.IndexOf(pattern, stringComparison) >= 0;
         }
 
+        [Obsolete(
+            "Either NameEquals() or NameMatches() without the useRegularExpressions parameter should be used"
+        )]
+        public static bool NameMatches(
+            this IHasName cls,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            if (useRegularExpressions)
+            {
+                return pattern != null && Regex.IsMatch(cls.Name, pattern);
+            }
+
+            return string.Equals(cls.Name, pattern, StringComparison.OrdinalIgnoreCase);
+        }
+
         public static bool NameEquals(this IHasName cls, string name)
         {
             return string.Equals(cls.Name, name, StringComparison.OrdinalIgnoreCase);
@@ -46,6 +63,23 @@ public static bool NameMatches(this IHasName cls, string pattern)
             return pattern != null && Regex.IsMatch(cls.Name, pattern);
         }
 
+        [Obsolete(
+            "Either FullNameEquals() or FullNameMatches() without the useRegularExpressions parameter should be used"
+        )]
+        public static bool FullNameMatches(
+            this IHasName cls,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            if (useRegularExpressions)
+            {
+                return pattern != null && Regex.IsMatch(cls.FullName, pattern);
+            }
+
+            return string.Equals(cls.FullName, pattern, StringComparison.OrdinalIgnoreCase);
+        }
+
         public static bool FullNameEquals(this IHasName cls, string fullName)
         {
             return string.Equals(cls.FullName, fullName, StringComparison.OrdinalIgnoreCase);

ArchUnitNET/Domain/Extensions/TypeExtensions.cs

@@ -19,6 +19,25 @@ public static bool ImplementsInterface(this IType type, Interface intf)
             );
         }
 
+        [Obsolete(
+            "Either ImplementsInterface() without the useRegularExpressions parameter or ImplementsInterfaceMatching() should be used"
+        )]
+        public static bool ImplementsInterface(
+            this IType type,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            if (type is GenericParameter)
+            {
+                return false;
+            }
+
+            return type.ImplementedInterfaces.Any(implementedInterface =>
+                implementedInterface.FullNameMatches(pattern, useRegularExpressions)
+            );
+        }
+
         public static bool ImplementsInterface(this IType type, string fullName)
         {
             if (type is GenericParameter)
@@ -55,6 +74,26 @@ public static bool IsAssignableTo(this IType type, IType assignableToType)
             return type.GetAssignableTypes().Contains(assignableToType);
         }
 
+        [Obsolete(
+            "Either IsAssignableTo() without the useRegularExpressions parameter or IsAssignableToTypeMatching() should be used"
+        )]
+        public static bool IsAssignableTo(
+            this IType type,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            if (type is GenericParameter genericParameter)
+            {
+                return genericParameter.TypeConstraints.All(t =>
+                    t.IsAssignableTo(pattern, useRegularExpressions)
+                );
+            }
+
+            return type.GetAssignableTypes()
+                .Any(t => t.FullNameMatches(pattern, useRegularExpressions));
+        }
+
         public static bool IsAssignableTo(this IType type, string fullName)
         {
             if (type is GenericParameter genericParameter)
@@ -239,6 +278,18 @@ public static Attribute GetAttributeOfType(this IType type, Class attributeClass
             );
         }
 
+        [Obsolete(
+            "Either ResidesInNamespace() without the useRegularExpressions parameter or ResidesInNamespaceMatching() should be used"
+        )]
+        public static bool ResidesInNamespace(
+            this IType e,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            return e.Namespace.FullNameMatches(pattern, useRegularExpressions);
+        }
+
         public static bool ResidesInNamespace(this IType e, string fullName)
         {
             return e.Namespace.FullNameEquals(fullName);
@@ -249,6 +300,18 @@ public static bool ResidesInNamespaceMatching(this IType e, string pattern)
             return e.Namespace.FullNameMatches(pattern);
         }
 
+        [Obsolete(
+            "Either ResidesInAssembly() without the useRegularExpressions parameter or ResidesInAssemblyMatching() should be used"
+        )]
+        public static bool ResidesInAssembly(
+            this IType e,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            return e.Assembly.FullNameMatches(pattern, useRegularExpressions);
+        }
+
         public static bool ResidesInAssembly(this IType e, string fullName)
         {
             return e.Assembly.FullNameEquals(fullName);
@@ -259,6 +322,21 @@ public static bool ResidesInAssemblyMatching(this IType e, string pattern)
             return e.Assembly.FullNameMatches(pattern);
         }
 
+        [Obsolete(
+            "Either IsDeclaredAsFieldIn() without the useRegularExpressions parameter or IsDeclaredAsFieldInTypeMatching() should be used"
+        )]
+        public static bool IsDeclaredAsFieldIn(
+            this IType type,
+            string pattern,
+            bool useRegularExpressions
+        )
+        {
+            return type.GetFieldTypeDependencies(true)
+                .Any(dependency =>
+                    dependency.Target.FullNameMatches(pattern, useRegularExpressions)
+                );
+        }
+
         public static bool IsDeclaredAsFieldIn(this IType type, string fullName)
         {
             return type.GetFieldTypeDependencies(true)

ArchUnitNET/Domain/PlantUml/Export/DependencyFilters.cs

@@ -50,6 +50,19 @@ public static Func<ITypeDependency, bool> FocusOn(IEnumerable<IType> types)
             };
         }
 
+        [Obsolete(
+            "Another overload of this method should be used. This will be removed in a future update."
+        )]
+        public static Func<ITypeDependency, bool> FocusOn(
+            string pattern,
+            bool useRegularExpressions = false
+        )
+        {
+            return dependency =>
+                dependency.Target.FullNameMatches(pattern, useRegularExpressions)
+                ^ dependency.Origin.FullNameMatches(pattern, useRegularExpressions);
+        }
+
         public static Func<ITypeDependency, bool> HasOrigin(IType type)
         {
             return dependency => dependency.Origin.Equals(type);
@@ -60,6 +73,17 @@ public static Func<ITypeDependency, bool> HasOrigin(IEnumerable<IType> types)
             return dependency => types.Contains(dependency.Origin);
         }
 
+        [Obsolete(
+            "Another overload of this method should be used. This will be removed in a future update."
+        )]
+        public static Func<ITypeDependency, bool> HasOrigin(
+            string pattern,
+            bool useRegularExpressions = false
+        )
+        {
+            return dependency => dependency.Origin.FullNameMatches(pattern, useRegularExpressions);
+        }
+
         public static Func<ITypeDependency, bool> HasTarget(IType type)
         {
             return dependency => dependency.Target.Equals(type);
@@ -69,5 +93,16 @@ public static Func<ITypeDependency, bool> HasTarget(IEnumerable<IType> types)
         {
             return dependency => types.Contains(dependency.Target);
         }
+
+        [Obsolete(
+            "Another overload of this method should be used. This will be removed in a future update."
+        )]
+        public static Func<ITypeDependency, bool> HasTarget(
+            string pattern,
+            bool useRegularExpressions = false
+        )
+        {
+            return dependency => dependency.Target.FullNameMatches(pattern, useRegularExpressions);
+        }
     }
 }