Skip to content

Refactor Fluent Syntax to have a single implementation of each method #444

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
alexanderlinne wants to merge 2 commits into
base: main
Choose a base branch
from
Open

Refactor Fluent Syntax to have a single implementation of each method #444

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
3c04b49
Refactor Fluent Syntax to have a single implementation of each method
alexanderlinne Jan 9, 2026
bcc8a02
Rename Generic Parameters
alexanderlinne Dec 18, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
237 changes: 237 additions & 0 deletions ArchUnitNET/Fluent/Syntax/Elements/AddObjectCondition.cs
View file
Open in desktop

Large diffs are not rendered by default.

164 changes: 164 additions & 0 deletions ArchUnitNET/Fluent/Syntax/Elements/AddObjectPredicate.cs
View file
Open in desktop

Large diffs are not rendered by default.

168 changes: 0 additions & 168 deletions ArchUnitNET/Fluent/Syntax/Elements/GivenObjectsThat.cs
View file
Open in desktop

This file was deleted.

168 changes: 168 additions & 0 deletions ArchUnitNET/Fluent/Syntax/Elements/IAddObjectCondition.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,168 @@
using System;
using System.Collections.Generic;
using ArchUnitNET.Domain;
using ArchUnitNET.Fluent.Conditions;
using ArchUnitNET.Fluent.Syntax.Elements.Types;
using ArchUnitNET.Fluent.Syntax.Elements.Types.Attributes;
using Attribute = ArchUnitNET.Domain.Attribute;

namespace ArchUnitNET.Fluent.Syntax.Elements
{
public interface IAddObjectCondition<TNextElement, TRuleType>
where TRuleType : ICanBeAnalyzed
{
// csharpier-ignore-start

TNextElement Exist();

TNextElement Be(params ICanBeAnalyzed[] objects);
TNextElement Be(IEnumerable<ICanBeAnalyzed> objects);
TNextElement Be(IObjectProvider<ICanBeAnalyzed> objects);

TNextElement CallAny(params MethodMember[] methods);
TNextElement CallAny(IEnumerable<MethodMember> methods);
TNextElement CallAny(IObjectProvider<MethodMember> methods);

TNextElement DependOnAny();
TNextElement DependOnAny(params IType[] types);
TNextElement DependOnAny(params Type[] types);
TNextElement DependOnAny(IObjectProvider<IType> types);
TNextElement DependOnAny(IEnumerable<IType> types);
TNextElement DependOnAny(IEnumerable<Type> types);
ShouldRelateToTypesThat<TNextElement, TRuleType> DependOnAnyTypesThat();

TNextElement FollowCustomCondition(ICondition<TRuleType> condition);
TNextElement FollowCustomCondition(Func<TRuleType, ConditionResult> condition, string description);
TNextElement FollowCustomCondition(Func<TRuleType, bool> condition, string description, string failDescription);

TNextElement OnlyDependOn();
TNextElement OnlyDependOn(params IType[] types);
TNextElement OnlyDependOn(params Type[] types);
TNextElement OnlyDependOn(IObjectProvider<IType> types);
TNextElement OnlyDependOn(IEnumerable<IType> types);
TNextElement OnlyDependOn(IEnumerable<Type> types);
ShouldRelateToTypesThat<TNextElement, TRuleType> OnlyDependOnTypesThat();

TNextElement HaveAnyAttributes();
TNextElement HaveAnyAttributes(params Attribute[] attributes);
TNextElement HaveAnyAttributes(params Type[] attributes);
TNextElement HaveAnyAttributes(IObjectProvider<Attribute> attributes);
TNextElement HaveAnyAttributes(IEnumerable<Attribute> attributes);
TNextElement HaveAnyAttributes(IEnumerable<Type> attributes);
ShouldRelateToAttributesThat<TNextElement, TRuleType> HaveAnyAttributesThat();

TNextElement OnlyHaveAttributes();
TNextElement OnlyHaveAttributes(params Attribute[] attributes);
TNextElement OnlyHaveAttributes(params Type[] attributes);
TNextElement OnlyHaveAttributes(IObjectProvider<Attribute> attributes);
TNextElement OnlyHaveAttributes(IEnumerable<Attribute> attributes);
TNextElement OnlyHaveAttributes(IEnumerable<Type> attributes);
ShouldRelateToAttributesThat<TNextElement, TRuleType> OnlyHaveAttributesThat();

TNextElement HaveAnyAttributesWithArguments(IEnumerable<object> argumentValues);

TNextElement HaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues);
TNextElement HaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues);

TNextElement HaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments);
TNextElement HaveAnyAttributesWithNamedArguments(params (string, object)[] attributeArguments);

TNextElement HaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments);
TNextElement HaveAttributeWithNamedArguments(Attribute attribute, params (string, object)[] attributeArguments);
TNextElement HaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments);
TNextElement HaveAttributeWithNamedArguments(Type attribute, params (string, object)[] attributeArguments);

TNextElement HaveName(string name);
TNextElement HaveNameMatching(string pattern);
TNextElement HaveNameStartingWith(string pattern);
TNextElement HaveNameEndingWith(string pattern);
TNextElement HaveNameContaining(string pattern);

TNextElement HaveFullName(string fullName);
TNextElement HaveFullNameMatching(string pattern);
TNextElement HaveFullNameStartingWith(string pattern);
TNextElement HaveFullNameEndingWith(string pattern);
TNextElement HaveFullNameContaining(string pattern);

TNextElement HaveAssemblyQualifiedName(string assemblyQualifiedName);
TNextElement HaveAssemblyQualifiedNameMatching(string pattern);
TNextElement HaveAssemblyQualifiedNameStartingWith(string pattern);
TNextElement HaveAssemblyQualifiedNameEndingWith(string pattern);
TNextElement HaveAssemblyQualifiedNameContaining(string pattern);

TNextElement BePrivate();
TNextElement BePublic();
TNextElement BeProtected();
TNextElement BeInternal();
TNextElement BeProtectedInternal();
TNextElement BePrivateProtected();

//Negations

TNextElement NotExist();

TNextElement NotBe(params ICanBeAnalyzed[] objects);
TNextElement NotBe(IEnumerable<ICanBeAnalyzed> objects);
TNextElement NotBe(IObjectProvider<ICanBeAnalyzed> objects);

TNextElement NotCallAny(params MethodMember[] methods);
TNextElement NotCallAny(IEnumerable<MethodMember> methods);
TNextElement NotCallAny(IObjectProvider<MethodMember> methods);

TNextElement NotDependOnAny();
TNextElement NotDependOnAny(params IType[] types);
TNextElement NotDependOnAny(params Type[] types);
TNextElement NotDependOnAny(IObjectProvider<IType> types);
TNextElement NotDependOnAny(IEnumerable<IType> types);
TNextElement NotDependOnAny(IEnumerable<Type> types);
ShouldRelateToTypesThat<TNextElement, TRuleType> NotDependOnAnyTypesThat();

TNextElement NotHaveAnyAttributes();
TNextElement NotHaveAnyAttributes(params Attribute[] attributes);
TNextElement NotHaveAnyAttributes(params Type[] attributes);
TNextElement NotHaveAnyAttributes(IObjectProvider<Attribute> attributes);
TNextElement NotHaveAnyAttributes(IEnumerable<Attribute> attributes);
TNextElement NotHaveAnyAttributes(IEnumerable<Type> attributes);
ShouldRelateToAttributesThat<TNextElement, TRuleType> NotHaveAnyAttributesThat();

TNextElement NotHaveAnyAttributesWithArguments(IEnumerable<object> argumentValues);

TNextElement NotHaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues);
TNextElement NotHaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues);

TNextElement NotHaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments);
TNextElement NotHaveAnyAttributesWithNamedArguments(params (string, object)[] attributeArguments);

TNextElement NotHaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments);
TNextElement NotHaveAttributeWithNamedArguments(Attribute attribute, params (string, object)[] attributeArguments);
TNextElement NotHaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments);
TNextElement NotHaveAttributeWithNamedArguments(Type attribute, params (string, object)[] attributeArguments);

TNextElement NotHaveName(string name);
TNextElement NotHaveNameMatching(string pattern);
TNextElement NotHaveNameStartingWith(string pattern);
TNextElement NotHaveNameEndingWith(string pattern);
TNextElement NotHaveNameContaining(string pattern);

TNextElement NotHaveFullName(string fullName);
TNextElement NotHaveFullNameMatching(string pattern);
TNextElement NotHaveFullNameStartingWith(string pattern);
TNextElement NotHaveFullNameEndingWith(string pattern);
TNextElement NotHaveFullNameContaining(string pattern);

TNextElement NotHaveAssemblyQualifiedName(string assemblyQualifiedName);
TNextElement NotHaveAssemblyQualifiedNameMatching(string pattern);
TNextElement NotHaveAssemblyQualifiedNameStartingWith(string pattern);
TNextElement NotHaveAssemblyQualifiedNameEndingWith(string pattern);
TNextElement NotHaveAssemblyQualifiedNameContaining(string pattern);

TNextElement NotBePrivate();
TNextElement NotBePublic();
TNextElement NotBeProtected();
TNextElement NotBeInternal();
TNextElement NotBeProtectedInternal();
TNextElement NotBePrivateProtected();

// csharpier-ignore-end
}
}
155 changes: 155 additions & 0 deletions ArchUnitNET/Fluent/Syntax/Elements/IAddObjectPredicate.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,155 @@
using System;
using System.Collections.Generic;
using ArchUnitNET.Domain;
using ArchUnitNET.Fluent.Predicates;
using Attribute = ArchUnitNET.Domain.Attribute;

namespace ArchUnitNET.Fluent.Syntax.Elements
{
public interface IAddObjectPredicate<out TNextElement, TRuleType>
where TRuleType : ICanBeAnalyzed
{
// csharpier-ignore-start

TNextElement FollowCustomPredicate(IPredicate<TRuleType> predicate);
TNextElement FollowCustomPredicate(Func<TRuleType, bool> predicate, string description);

TNextElement Are(params ICanBeAnalyzed[] objects);
TNextElement Are(IEnumerable<ICanBeAnalyzed> objects);
TNextElement Are(IObjectProvider<ICanBeAnalyzed> objects);

TNextElement CallAny(params MethodMember[] methods);
TNextElement CallAny(IEnumerable<MethodMember> methods);
TNextElement CallAny(IObjectProvider<MethodMember> methods);

TNextElement DependOnAny();
TNextElement DependOnAny(params IType[] types);
TNextElement DependOnAny(params Type[] types);
TNextElement DependOnAny(IEnumerable<IType> types);
TNextElement DependOnAny(IEnumerable<Type> types);
TNextElement DependOnAny(IObjectProvider<IType> types);

TNextElement OnlyDependOn();
TNextElement OnlyDependOn(params IType[] types);
TNextElement OnlyDependOn(params Type[] types);
TNextElement OnlyDependOn(IEnumerable<IType> types);
TNextElement OnlyDependOn(IEnumerable<Type> types);
TNextElement OnlyDependOn(IObjectProvider<IType> types);

TNextElement HaveAnyAttributes();
TNextElement HaveAnyAttributes(params Attribute[] attributes);
TNextElement HaveAnyAttributes(params Type[] attributes);
TNextElement HaveAnyAttributes(IEnumerable<Attribute> attributes);
TNextElement HaveAnyAttributes(IEnumerable<Type> attributes);
TNextElement HaveAnyAttributes(IObjectProvider<Attribute> attributes);

TNextElement OnlyHaveAttributes();
TNextElement OnlyHaveAttributes(params Attribute[] attributes);
TNextElement OnlyHaveAttributes(params Type[] attributes);
TNextElement OnlyHaveAttributes(IEnumerable<Attribute> attributes);
TNextElement OnlyHaveAttributes(IEnumerable<Type> attributes);
TNextElement OnlyHaveAttributes(IObjectProvider<Attribute> attributes);

TNextElement HaveAnyAttributesWithArguments(IEnumerable<object> argumentValues);

TNextElement HaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues);
TNextElement HaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues);

TNextElement HaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments);
TNextElement HaveAnyAttributesWithNamedArguments(params (string, object)[] attributeArguments);

TNextElement HaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments);
TNextElement HaveAttributeWithNamedArguments(Attribute attribute, params (string, object)[] attributeArguments);
TNextElement HaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments);
TNextElement HaveAttributeWithNamedArguments(Type attribute, params (string, object)[] attributeArguments);

TNextElement HaveName(string name);
TNextElement HaveNameMatching(string pattern);
TNextElement HaveNameStartingWith(string pattern);
TNextElement HaveNameEndingWith(string pattern);
TNextElement HaveNameContaining(string pattern);

TNextElement HaveFullName(string fullName);
TNextElement HaveFullNameMatching(string pattern);
TNextElement HaveFullNameStartingWith(string pattern);
TNextElement HaveFullNameEndingWith(string pattern);
TNextElement HaveFullNameContaining(string pattern);

TNextElement HaveAssemblyQualifiedName(string assemblyQualifiedName);
TNextElement HaveAssemblyQualifiedNameMatching(string pattern);
TNextElement HaveAssemblyQualifiedNameStartingWith(string pattern);
TNextElement HaveAssemblyQualifiedNameEndingWith(string pattern);
TNextElement HaveAssemblyQualifiedNameContaining(string pattern);

TNextElement ArePrivate();
TNextElement ArePublic();
TNextElement AreProtected();
TNextElement AreInternal();
TNextElement AreProtectedInternal();
TNextElement ArePrivateProtected();

//Negations

TNextElement AreNot(params ICanBeAnalyzed[] objects);
TNextElement AreNot(IEnumerable<ICanBeAnalyzed> objects);
TNextElement AreNot(IObjectProvider<ICanBeAnalyzed> objects);

TNextElement DoNotCallAny(params MethodMember[] methods);
TNextElement DoNotCallAny(IEnumerable<MethodMember> methods);
TNextElement DoNotCallAny(IObjectProvider<MethodMember> methods);

TNextElement DoNotDependOnAny();
TNextElement DoNotDependOnAny(params IType[] types);
TNextElement DoNotDependOnAny(params Type[] types);
TNextElement DoNotDependOnAny(IObjectProvider<IType> types);
TNextElement DoNotDependOnAny(IEnumerable<IType> types);
TNextElement DoNotDependOnAny(IEnumerable<Type> types);

TNextElement DoNotHaveAnyAttributes();
TNextElement DoNotHaveAnyAttributes(params Attribute[] attributes);
TNextElement DoNotHaveAnyAttributes(params Type[] attributes);
TNextElement DoNotHaveAnyAttributes(IObjectProvider<Attribute> attributes);
TNextElement DoNotHaveAnyAttributes(IEnumerable<Attribute> attributes);
TNextElement DoNotHaveAnyAttributes(IEnumerable<Type> attributes);

TNextElement DoNotHaveAnyAttributesWithArguments(IEnumerable<object> argumentValues);

TNextElement DoNotHaveAttributeWithArguments(Attribute attribute, IEnumerable<object> argumentValues);
TNextElement DoNotHaveAttributeWithArguments(Type attribute, IEnumerable<object> argumentValues);

TNextElement DoNotHaveAnyAttributesWithNamedArguments(IEnumerable<(string, object)> attributeArguments);
TNextElement DoNotHaveAnyAttributesWithNamedArguments(params (string, object)[] attributeArguments);

TNextElement DoNotHaveAttributeWithNamedArguments(Attribute attribute, IEnumerable<(string, object)> attributeArguments);
TNextElement DoNotHaveAttributeWithNamedArguments(Attribute attribute, params (string, object)[] attributeArguments);
TNextElement DoNotHaveAttributeWithNamedArguments(Type attribute, IEnumerable<(string, object)> attributeArguments);
TNextElement DoNotHaveAttributeWithNamedArguments(Type attribute, params (string, object)[] attributeArguments);

TNextElement DoNotHaveName(string name);
TNextElement DoNotHaveNameMatching(string pattern);
TNextElement DoNotHaveNameStartingWith(string pattern);
TNextElement DoNotHaveNameEndingWith(string pattern);
TNextElement DoNotHaveNameContaining(string pattern);

TNextElement DoNotHaveFullName(string fullName);
TNextElement DoNotHaveFullNameMatching(string pattern);
TNextElement DoNotHaveFullNameStartingWith(string pattern);
TNextElement DoNotHaveFullNameEndingWith(string pattern);
TNextElement DoNotHaveFullNameContaining(string pattern);

TNextElement DoNotHaveAssemblyQualifiedName(string assemblyQualifiedName);
TNextElement DoNotHaveAssemblyQualifiedNameMatching(string pattern);
TNextElement DoNotHaveAssemblyQualifiedNameStartingWith(string pattern);
TNextElement DoNotHaveAssemblyQualifiedNameEndingWith(string pattern);
TNextElement DoNotHaveAssemblyQualifiedNameContaining(string pattern);

TNextElement AreNotPrivate();
TNextElement AreNotPublic();
TNextElement AreNotProtected();
TNextElement AreNotInternal();
TNextElement AreNotProtectedInternal();
TNextElement AreNotPrivateProtected();

// csharpier-ignore-end
}
}
25 changes: 0 additions & 25 deletions ArchUnitNET/Fluent/Syntax/Elements/IComplexObjectConditions.cs
View file
Open in desktop

This file was deleted.

Loading