ArchUnit#704: classes structure modification

Signed-off-by: Justyna Kubica-Ledzion <[email protected]>

archunit/src/main/java/com/tngtech/archunit/core/domain/JavaCodeUnit.java

@@ -378,9 +378,6 @@ public ThrowsClause<T> apply(T input) {
                 };
             }
 
-            /**
-             * @see #getCallsOfSelf()
-             */
             @PublicAPI(usage = ACCESS)
             public static final ChainableFunction<JavaCodeUnit, Set<? extends JavaCall<?>>> GET_CALLS_OF_SELF =
                     new ChainableFunction<JavaCodeUnit, Set<? extends JavaCall<?>>>() {

archunit/src/main/java/com/tngtech/archunit/lang/conditions/AllAccessesCondition.java

@@ -23,7 +23,7 @@
 import com.tngtech.archunit.core.domain.JavaAccess;
 import com.tngtech.archunit.core.domain.JavaClass;
 
-class AllAccessesCondition extends AllAttributesMatchCondition<JavaAccess<?>> {
+class AllAccessesCondition extends AllAttributesMatchCondition<JavaAccess<?>, JavaClass> {
     private final Function<JavaClass, ? extends Collection<JavaAccess<?>>> getRelevantAccesses;
 
     AllAccessesCondition(String prefix, DescribedPredicate<JavaAccess<?>> predicate,

archunit/src/main/java/com/tngtech/archunit/lang/conditions/AllAttributesMatchCondition.java

@@ -17,26 +17,25 @@
 
 import java.util.Collection;
 
-import com.tngtech.archunit.core.domain.JavaClass;
 import com.tngtech.archunit.lang.ArchCondition;
 import com.tngtech.archunit.lang.ConditionEvents;
 
 import static com.tngtech.archunit.lang.conditions.ArchConditions.containOnlyElementsThat;
 
-abstract class AllAttributesMatchCondition<T> extends ArchCondition<JavaClass> {
-    private final ArchCondition<T> condition;
+abstract class AllAttributesMatchCondition<ATTRIBUTE, OWNER> extends ArchCondition<OWNER> {
+    private final ArchCondition<ATTRIBUTE> condition;
 
-    AllAttributesMatchCondition(String description, ArchCondition<T> condition) {
+    AllAttributesMatchCondition(String description, ArchCondition<ATTRIBUTE> condition) {
         super(description);
         this.condition = condition;
     }
 
     @Override
-    public final void check(JavaClass item, ConditionEvents events) {
+    public final void check(OWNER item, ConditionEvents events) {
         containOnlyElementsThat(condition).check(relevantAttributes(item), events);
     }
 
-    abstract Collection<T> relevantAttributes(JavaClass item);
+    abstract Collection<ATTRIBUTE> relevantAttributes(OWNER item);
 
     @Override
     public String toString() {

archunit/src/main/java/com/tngtech/archunit/lang/conditions/AllDependenciesCondition.java

@@ -28,7 +28,7 @@
 import static com.tngtech.archunit.PublicAPI.Usage.ACCESS;
 
 @PublicAPI(usage = ACCESS)
-public final class AllDependenciesCondition extends AllAttributesMatchCondition<Dependency> {
+public final class AllDependenciesCondition extends AllAttributesMatchCondition<Dependency, JavaClass> {
     private final DescribedPredicate<? super Dependency> conditionPredicate;
     private final Function<JavaClass, ? extends Collection<Dependency>> javaClassToRelevantDependencies;
     private final DescribedPredicate<Dependency> ignorePredicate;

archunit/src/main/java/com/tngtech/archunit/lang/conditions/ArchConditions.java

@@ -1213,28 +1213,28 @@ public static ArchCondition<JavaCodeUnit> declareThrowableOfType(DescribedPredic
     public static ArchCondition<JavaCodeUnit> onlyBeCalledByClassesThat(DescribedPredicate<? super JavaClass> predicate) {
         ChainableFunction<JavaAccess<?>, JavaCodeUnit> origin = JavaAccess.Functions.Get.origin();
         ChainableFunction<HasOwner<JavaClass>, JavaClass> owner = Get.owner();
-        return new CodeUnitCallsCondition(Joiner.on(" ").join("only be called by classes that", predicate.getDescription()),
+        return new CodeUnitOnlyCallsCondition("only be called by classes that " + predicate.getDescription(),
                 origin.then(owner).is(predicate), GET_CALLS_OF_SELF);
     }
 
     @PublicAPI(usage = ACCESS)
     public static ArchCondition<JavaCodeUnit> onlyBeCalledByMethodsThat(DescribedPredicate<? super JavaMember> predicate) {
         ChainableFunction<JavaAccess<?>, ? extends JavaCodeUnit> origin = JavaAccess.Functions.Get.origin();
-        return new CodeUnitCallsCondition(Joiner.on(" ").join("only be called by methods that", predicate.getDescription()),
+        return new CodeUnitOnlyCallsCondition("only be called by methods that " + predicate.getDescription(),
                 origin.is(method().and(predicate)), GET_CALLS_OF_SELF);
     }
 
     @PublicAPI(usage = ACCESS)
     public static ArchCondition<JavaCodeUnit> onlyBeCalledByConstructorsThat(DescribedPredicate<? super JavaMember> predicate) {
         ChainableFunction<JavaAccess<?>, ? extends JavaCodeUnit> origin = JavaAccess.Functions.Get.origin();
-        return new CodeUnitCallsCondition(Joiner.on(" ").join("only be called by constructors that", predicate.getDescription()),
+        return new CodeUnitOnlyCallsCondition("only be called by constructors that " + predicate.getDescription(),
                 origin.is(constructor().and(predicate)), GET_CALLS_OF_SELF);
     }
 
     @PublicAPI(usage = ACCESS)
     public static ArchCondition<JavaCodeUnit> onlyBeCalledByCodeUnitsThat(DescribedPredicate<? super JavaMember> predicate) {
         ChainableFunction<JavaAccess<?>, ? extends JavaCodeUnit> origin = JavaAccess.Functions.Get.origin();
-        return new CodeUnitCallsCondition(Joiner.on(" ").join("only be called by code units that", predicate.getDescription()),
+        return new CodeUnitOnlyCallsCondition("only be called by code units that " + predicate.getDescription(),
                 origin.is(predicate), GET_CALLS_OF_SELF);
     }
 
@@ -1256,7 +1256,7 @@ private static <T extends HasDescription & HasSourceCodeLocation> String createM
             new IsConditionByPredicate<>("a local class", JavaClass.Predicates.LOCAL_CLASSES);
 
     private static class HaveOnlyModifiersCondition<T extends HasModifiers & HasDescription & HasSourceCodeLocation>
-            extends AllAttributesMatchCondition<T> {
+            extends AllAttributesMatchCondition<T, JavaClass> {
 
         private final Function<JavaClass, ? extends Collection<T>> getHasModifiers;
 

archunit/src/main/java/com/tngtech/archunit/lang/conditions/ClassOnlyAccessesCondition.java

@@ -22,7 +22,7 @@
 import com.tngtech.archunit.core.domain.JavaAccess;
 import com.tngtech.archunit.core.domain.JavaClass;
 
-class ClassOnlyAccessesCondition<T extends JavaAccess<?>> extends AllAttributesMatchCondition<T> {
+class ClassOnlyAccessesCondition<T extends JavaAccess<?>> extends AllAttributesMatchCondition<T, JavaClass> {
     private final Function<JavaClass, ? extends Collection<T>> getRelevantAccesses;
 
     ClassOnlyAccessesCondition(DescribedPredicate<? super T> predicate, Function<JavaClass, ? extends Collection<T>> getRelevantAccesses) {

archunit/src/main/java/com/tngtech/archunit/lang/conditions/CodeUnitCallsCondition.java → archunit/src/main/java/com/tngtech/archunit/lang/conditions/CodeUnitOnlyCallsCondition.java

@@ -21,32 +21,18 @@
 import com.tngtech.archunit.base.Function;
 import com.tngtech.archunit.core.domain.JavaAccess;
 import com.tngtech.archunit.core.domain.JavaCodeUnit;
-import com.tngtech.archunit.lang.ArchCondition;
-import com.tngtech.archunit.lang.ConditionEvents;
 
-class CodeUnitCallsCondition extends ArchCondition<JavaCodeUnit> {
+class CodeUnitOnlyCallsCondition<T extends JavaAccess<?>> extends AllAttributesMatchCondition<T, JavaCodeUnit> {
+    private final Function<? super JavaCodeUnit, ? extends Collection<T>> getRelevantAccesses;
 
-    private final ArchCondition<JavaAccess<?>> condition;
-    private final Function<? super JavaCodeUnit, ? extends Collection<? extends JavaAccess<?>>> getRelevantAccesses;
-
-    CodeUnitCallsCondition(String description, DescribedPredicate<JavaAccess<?>> predicate,
-            Function<? super JavaCodeUnit, ? extends Collection<? extends JavaAccess<?>>> getRelevantAccesses) {
-        super(description);
-        this.condition = new JavaAccessCondition<>(predicate);
+    CodeUnitOnlyCallsCondition(String description, DescribedPredicate<T> predicate,
+            Function<? super JavaCodeUnit, ? extends Collection<T>> getRelevantAccesses) {
+        super(description, new JavaAccessCondition<>(predicate));
         this.getRelevantAccesses = getRelevantAccesses;
     }
 
     @Override
-    public final void check(JavaCodeUnit item, ConditionEvents events) {
-        ArchConditions.containOnlyElementsThat(condition).check(relevantAttributes(item), events);
-    }
-
-    private Collection<? extends JavaAccess<?>> relevantAttributes(JavaCodeUnit item) {
+    Collection<T> relevantAttributes(JavaCodeUnit item) {
         return getRelevantAccesses.apply(item);
     }
-
-    @Override
-    public String toString() {
-        return getClass().getSimpleName() + "{condition=" + condition + "}";
-    }
 }

archunit/src/main/java/com/tngtech/archunit/lang/syntax/AbstractCodeUnitsShouldInternal.java

@@ -178,7 +178,7 @@ CodeUnitsShouldInternal copyWithNewCondition(ConditionAggregator<JavaCodeUnit> n
 
         @Override
         public OnlyBeCalledSpecification<CodeUnitsShouldInternal> onlyBeCalled() {
-            return new OnlyBeCalledCodeUnitSpecificationInternal(this);
+            return new OnlyBeCalledSpecificationInternal(this);
         }
     }
 }

archunit/src/main/java/com/tngtech/archunit/lang/syntax/ConstructorsShouldInternal.java

@@ -55,6 +55,6 @@ ConstructorsShouldInternal copyWithNewCondition(ConditionAggregator<JavaConstruc
 
     @Override
     public OnlyBeCalledSpecification<ConstructorsShouldInternal> onlyBeCalled() {
-        return new OnlyBeCalledConstructorSpecificationInternal(this);
+        return new OnlyBeCalledSpecificationInternal<>(this);
     }
 }

archunit/src/main/java/com/tngtech/archunit/lang/syntax/MethodsShouldInternal.java

@@ -61,6 +61,6 @@ MethodsShouldInternal copyWithNewCondition(ConditionAggregator<JavaMethod> newCo
 
     @Override
     public OnlyBeCalledSpecification<MethodsShouldInternal> onlyBeCalled() {
-        return new OnlyBeCalledMethodSpecificationInternal(this);
+        return new OnlyBeCalledSpecificationInternal<>(this);
     }
 }

archunit/src/main/java/com/tngtech/archunit/lang/syntax/OnlyBeCalledCodeUnitSpecificationInternal.java → archunit/src/main/java/com/tngtech/archunit/lang/syntax/OnlyBeCalledSpecificationInternal.java

@@ -18,47 +18,47 @@
 import com.tngtech.archunit.base.DescribedPredicate;
 import com.tngtech.archunit.base.Function;
 import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.core.domain.JavaCodeUnit;
 import com.tngtech.archunit.core.domain.JavaMember;
 import com.tngtech.archunit.lang.conditions.ArchConditions;
 import com.tngtech.archunit.lang.syntax.elements.ClassesThat;
 import com.tngtech.archunit.lang.syntax.elements.OnlyBeCalledSpecification;
 
-import static com.tngtech.archunit.lang.syntax.AbstractCodeUnitsShouldInternal.CodeUnitsShouldInternal;
+class OnlyBeCalledSpecificationInternal<SHOULD extends AbstractMembersShouldInternal<? extends JavaCodeUnit, SHOULD>> implements
+        OnlyBeCalledSpecification<SHOULD> {
+    private final SHOULD codeUnitsShould;
 
-class OnlyBeCalledCodeUnitSpecificationInternal implements OnlyBeCalledSpecification<CodeUnitsShouldInternal> {
-    private final CodeUnitsShouldInternal codeUnitsShould;
-
-    OnlyBeCalledCodeUnitSpecificationInternal(CodeUnitsShouldInternal codeUnitsShould) {
+    OnlyBeCalledSpecificationInternal(SHOULD codeUnitsShould) {
         this.codeUnitsShould = codeUnitsShould;
     }
 
     @Override
-    public CodeUnitsShouldInternal byClassesThat(DescribedPredicate<? super JavaClass> predicate) {
+    public SHOULD byClassesThat(DescribedPredicate<? super JavaClass> predicate) {
         return codeUnitsShould.addCondition(ArchConditions.onlyBeCalledByClassesThat(predicate));
     }
 
     @Override
-    public CodeUnitsShouldInternal byMethodsThat(DescribedPredicate<? super JavaMember> predicate) {
-        return codeUnitsShould.addCondition(ArchConditions.onlyBeCalledByMethodsThat(predicate));
+    public ClassesThat<SHOULD> byClassesThat() {
+        return new ClassesThatInternal<>(new Function<DescribedPredicate<? super JavaClass>, SHOULD>() {
+            @Override
+            public SHOULD apply(DescribedPredicate<? super JavaClass> predicate) {
+                return codeUnitsShould.addCondition(ArchConditions.onlyBeCalledByClassesThat(predicate));
+            }
+        });
     }
 
     @Override
-    public CodeUnitsShouldInternal byConstructorsThat(DescribedPredicate<? super JavaMember> predicate) {
-        return codeUnitsShould.addCondition(ArchConditions.onlyBeCalledByConstructorsThat(predicate));
+    public SHOULD byMethodsThat(DescribedPredicate<? super JavaMember> predicate) {
+        return codeUnitsShould.addCondition(ArchConditions.onlyBeCalledByMethodsThat(predicate));
     }
 
     @Override
-    public CodeUnitsShouldInternal byCodeUnitsThat(DescribedPredicate<? super JavaMember> predicate) {
-        return codeUnitsShould.addCondition(ArchConditions.onlyBeCalledByCodeUnitsThat(predicate));
+    public SHOULD byConstructorsThat(DescribedPredicate<? super JavaMember> predicate) {
+        return codeUnitsShould.addCondition(ArchConditions.onlyBeCalledByConstructorsThat(predicate));
     }
 
     @Override
-    public ClassesThat<CodeUnitsShouldInternal> byClassesThat() {
-        return new ClassesThatInternal<>(new Function<DescribedPredicate<? super JavaClass>, CodeUnitsShouldInternal>() {
-            @Override
-            public CodeUnitsShouldInternal apply(DescribedPredicate<? super JavaClass> predicate) {
-                return codeUnitsShould.addCondition(ArchConditions.onlyBeCalledByClassesThat(predicate));
-            }
-        });
+    public SHOULD byCodeUnitsThat(DescribedPredicate<? super JavaMember> predicate) {
+        return codeUnitsShould.addCondition(ArchConditions.onlyBeCalledByCodeUnitsThat(predicate));
     }
 }

archunit/src/main/java/com/tngtech/archunit/lang/syntax/elements/CodeUnitsShould.java

@@ -74,13 +74,13 @@ public interface CodeUnitsShould<CONJUNCTION extends CodeUnitsShouldConjunction<
      * <br><br>
      * E.g.
      * <pre><code>
-     * {@link ArchRuleDefinition#codeUnits() codeUnits()}.{@link GivenCodeUnits#should() should()}.{@link CodeUnitsShould#onlyBeCalled()} onlyBeCalled().{@link OnlyBeCalledSpecification#byClassesThat(DescribedPredicate)}  byClassesThat(equivalentTo(SomeClass.class))}
+     * {@link ArchRuleDefinition#codeUnits() codeUnits()}.{@link GivenCodeUnits#should() should()}.{@link CodeUnitsShould#onlyBeCalled()} onlyBeCalled().{@link OnlyBeCalledSpecification#byClassesThat()}  byClassesThat().belongToAnyOf(SomeClass.class))}
      * </code></pre>
      *
      * @return A syntax element that allows restricting how code units can be called
      */
     @PublicAPI(usage = ACCESS)
-    OnlyBeCalledSpecification<? extends CodeUnitsShouldConjunction<? extends JavaCodeUnit>> onlyBeCalled();
+    OnlyBeCalledSpecification<CONJUNCTION> onlyBeCalled();
 
     /**
      * Asserts that {@link JavaCodeUnit JavaCodeUnits} have the specified fully qualified raw parameter type names.