Package com.tngtech.archunit.library.modules.syntax

Interface ModulesByAnnotationRule<ANNOTATION extends Annotation>

All Superinterfaces:

ArchRule, CanBeEvaluated, CanOverrideDescription<ArchRule>, HasDescription, ModulesRule<AnnotationDescriptor<ANNOTATION>>, ModulesShouldConjunction<AnnotationDescriptor<ANNOTATION>>

@PublicAPI(usage=ACCESS,
           state=EXPERIMENTAL)
public interface ModulesByAnnotationRule<ANNOTATION extends Annotation>
extends ModulesRule<AnnotationDescriptor<ANNOTATION>>

Nested Class Summary

Nested classes/interfaces inherited from interface com.tngtech.archunit.lang.ArchRule

ArchRule.Assertions, ArchRule.Factory, ArchRule.Transformation

Method Summary

Modifier and Type	Method	Description
ModulesByAnnotationRule<ANNOTATION>	allowEmptyShould(boolean allowEmptyShould)	If set to true allows the should-clause of this rule to be checked against an empty set of elements.
ModulesByAnnotationShould<ANNOTATION>	andShould()	Like ModulesShouldConjunction.andShould(ArchCondition) but offers a fluent API to pick the condition to join.
ModulesByAnnotationRule<ANNOTATION>	as(String newDescription)	Allows to adjust the description of this object.
ModulesByAnnotationRule<ANNOTATION>	because(String reason)
ModulesByAnnotationRule<ANNOTATION>	ignoreDependency(Class<?> origin, Class<?> target)	Ignores all class dependencies from the given origin class to the given target class.
ModulesByAnnotationRule<ANNOTATION>	ignoreDependency(String originFullyQualifiedClassName, String targetFullyQualifiedClassName)	Ignores all class dependencies from the origin class with the given fully qualified origin class name to the target class with the given fully qualified target class name.
ModulesByAnnotationRule<ANNOTATION>	ignoreDependency(Predicate<? super Dependency> dependencyPredicate)	Ignores all class dependencies matching the given predicate.
ModulesByAnnotationRule<ANNOTATION>	ignoreDependency(Predicate<? super JavaClass> originPredicate, Predicate<? super JavaClass> targetPredicate)	Ignores all class dependencies from any origin class matching the given origin class predicate to any target class matching the given target class predicate.

Methods inherited from interface com.tngtech.archunit.lang.ArchRule

check

Methods inherited from interface com.tngtech.archunit.lang.CanBeEvaluated

evaluate

Methods inherited from interface com.tngtech.archunit.base.HasDescription

getDescription

Methods inherited from interface com.tngtech.archunit.library.modules.syntax.ModulesShouldConjunction

andShould

Method Details

andShould

@PublicAPI(usage=ACCESS,
           state=EXPERIMENTAL)
ModulesByAnnotationShould<ANNOTATION> andShould()

Description copied from interface: ModulesShouldConjunction

Like ModulesShouldConjunction.andShould(ArchCondition) but offers a fluent API to pick the condition to join.

Specified by:

andShould in interface ModulesShouldConjunction<ANNOTATION extends Annotation>

as

@PublicAPI(usage=ACCESS,
           state=EXPERIMENTAL)
ModulesByAnnotationRule<ANNOTATION> as(String newDescription)

Description copied from interface: CanOverrideDescription

Allows to adjust the description of this object. Note that this method will not modify the current object, but instead return a new object with adjusted description.

Specified by:

as in interface CanOverrideDescription<ANNOTATION extends Annotation>

Specified by:

as in interface ModulesRule<ANNOTATION extends Annotation>

Parameters:

newDescription - The description the result of this method will hold

Returns:

A new equivalent object with adjusted description

because

@PublicAPI(usage=ACCESS,
           state=EXPERIMENTAL)
ModulesByAnnotationRule<ANNOTATION> because(String reason)

Specified by:

because in interface ArchRule

Specified by:

because in interface ModulesRule<ANNOTATION extends Annotation>

allowEmptyShould

@PublicAPI(usage=ACCESS,
           state=EXPERIMENTAL)
ModulesByAnnotationRule<ANNOTATION> allowEmptyShould(boolean allowEmptyShould)

Description copied from interface: ArchRule

If set to true allows the should-clause of this rule to be checked against an empty set of elements. Otherwise, the rule will fail with a respective message. This is to prevent possible implementation errors, like filtering for a non-existing package in the that-clause causing an always-passing rule.
Note that this method will override the configuration property archRule.failOnEmptyShould.

Specified by:

allowEmptyShould in interface ArchRule

Specified by:

allowEmptyShould in interface ModulesRule<ANNOTATION extends Annotation>

Parameters:

allowEmptyShould - Whether the rule fails if the should-clause is evaluated with an empty set of elements

Returns:

A (new) ArchRule with adjusted allowEmptyShould behavior

ignoreDependency

@PublicAPI(usage=ACCESS,
           state=EXPERIMENTAL)
ModulesByAnnotationRule<ANNOTATION> ignoreDependency(Class<?> origin,
 Class<?> target)

Description copied from interface: ModulesRule

Ignores all class dependencies from the given origin class to the given target class.

Note that this will always refer to the last ArchCondition only if multiple ArchConditions are joined using ModulesShouldConjunction.andShould(). E.g.

 modules()...
   .should().firstCondition()
   .ignoreDependency(/* will only refer to `firstCondition`, not to `secondCondition` */)
   .andShould().secondCondition()
   .ignoreDependency(/* will only refer to `secondCondition`, not to `firstCondition` */)
 

Specified by:

ignoreDependency in interface ModulesRule<ANNOTATION extends Annotation>

Parameters:

origin - the origin class of dependencies to ignore

target - the target class of dependencies to ignore

ignoreDependency

@PublicAPI(usage=ACCESS,
           state=EXPERIMENTAL)
ModulesByAnnotationRule<ANNOTATION> ignoreDependency(String originFullyQualifiedClassName,
 String targetFullyQualifiedClassName)

Description copied from interface: ModulesRule

Ignores all class dependencies from the origin class with the given fully qualified origin class name to the target class with the given fully qualified target class name.

Note that this will always refer to the last ArchCondition only if multiple ArchConditions are joined using ModulesShouldConjunction.andShould(). E.g.

 modules()...
   .should().firstCondition()
   .ignoreDependency(/* will only refer to `firstCondition`, not to `secondCondition` */)
   .andShould().secondCondition()
   .ignoreDependency(/* will only refer to `secondCondition`, not to `firstCondition` */)
 

Specified by:

ignoreDependency in interface ModulesRule<ANNOTATION extends Annotation>

Parameters:

originFullyQualifiedClassName - the fully qualified origin class of dependencies to ignore

targetFullyQualifiedClassName - the fully qualified target class of dependencies to ignore

ignoreDependency

@PublicAPI(usage=ACCESS,
           state=EXPERIMENTAL)
ModulesByAnnotationRule<ANNOTATION> ignoreDependency(Predicate<? super JavaClass> originPredicate,
 Predicate<? super JavaClass> targetPredicate)

Description copied from interface: ModulesRule

Ignores all class dependencies from any origin class matching the given origin class predicate to any target class matching the given target class predicate.

Note that this will always refer to the last ArchCondition only if multiple ArchConditions are joined using ModulesShouldConjunction.andShould(). E.g.

 modules()...
   .should().firstCondition()
   .ignoreDependency(/* will only refer to `firstCondition`, not to `secondCondition` */)
   .andShould().secondCondition()
   .ignoreDependency(/* will only refer to `secondCondition`, not to `firstCondition` */)
 

Specified by:

ignoreDependency in interface ModulesRule<ANNOTATION extends Annotation>

Parameters:

originPredicate - predicate determining for which origins of dependencies the dependency should be ignored

targetPredicate - predicate determining for which targets of dependencies the dependency should be ignored

ignoreDependency

@PublicAPI(usage=ACCESS,
           state=EXPERIMENTAL)
ModulesByAnnotationRule<ANNOTATION> ignoreDependency(Predicate<? super Dependency> dependencyPredicate)

Description copied from interface: ModulesRule

Ignores all class dependencies matching the given predicate.

Note that this will always refer to the last ArchCondition only if multiple ArchConditions are joined using ModulesShouldConjunction.andShould(). E.g.

 modules()...
   .should().firstCondition()
   .ignoreDependency(/* will only refer to `firstCondition`, not to `secondCondition` */)
   .andShould().secondCondition()
   .ignoreDependency(/* will only refer to `secondCondition`, not to `firstCondition` */)
 

Specified by:

ignoreDependency in interface ModulesRule<ANNOTATION extends Annotation>