add arch condition to check for any transitive dependency

Issue: #780
Signed-off-by: e.solutions <17569373+Pfoerd@users.noreply.github.com>
on-behalf-of: @e-esolutions-GmbH <info@esolutions.de>

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

@@ -0,0 +1,112 @@
+package com.tngtech.archunit.lang.conditions;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import com.google.common.collect.ImmutableList;
+import com.tngtech.archunit.base.DescribedPredicate;
+import com.tngtech.archunit.core.domain.Dependency;
+import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.lang.ArchCondition;
+import com.tngtech.archunit.lang.ConditionEvent;
+import com.tngtech.archunit.lang.ConditionEvents;
+import com.tngtech.archunit.lang.SimpleConditionEvent;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.getLast;
+import static java.util.stream.Collectors.joining;
+
+public class AnyTransitiveDependencyCondition extends ArchCondition<JavaClass> {
+
+    private final DescribedPredicate<? super JavaClass> conditionPredicate;
+    private final TransitiveDependencyPath transitiveDependencyPath = new TransitiveDependencyPath();
+    private Collection<JavaClass> allClasses;
+
+    public AnyTransitiveDependencyCondition(DescribedPredicate<? super JavaClass> conditionPredicate) {
+        super("transitively depend on any classes that " + conditionPredicate.getDescription());
+
+        this.conditionPredicate = checkNotNull(conditionPredicate);
+    }
+
+    @Override
+    public void init(Collection<JavaClass> allObjectsToTest) {
+        this.allClasses = allObjectsToTest;
+    }
+
+    @Override
+    public void check(JavaClass javaClass, ConditionEvents events) {
+        boolean hasTransitiveDependency = false;
+        for (JavaClass dependency : getDirectDependencies(javaClass)) {
+            if (!allClasses.contains(dependency)) {
+                List<JavaClass> dependencyPath = transitiveDependencyPath.findFirstPathToTransitiveDependency(dependency);
+                if (!dependencyPath.isEmpty()) {
+                    events.add(newTransitivePathFoundEvent(javaClass, dependencyPath));
+                    hasTransitiveDependency = true;
+                }
+            }
+        }
+        if (!hasTransitiveDependency) {
+            events.add(noTransitivePathFoundEvent(javaClass));
+        }
+    }
+
+    private static ConditionEvent newTransitivePathFoundEvent(JavaClass selected, List<JavaClass> transitivePath) {
+        String message =
+                String.format("Class <%s> transitively depends on <%s>", selected.getFullName(), getLast(transitivePath).getFullName());
+
+        if (transitivePath.size() > 1) {
+            message += " by [" + transitivePath.stream().map(JavaClass::getName).collect(joining("->")) + "]";
+        }
+        message += " in " + selected.getSourceCodeLocation();
+        return SimpleConditionEvent.satisfied(selected, message);
+    }
+
+    private static ConditionEvent noTransitivePathFoundEvent(JavaClass selected) {
+        return SimpleConditionEvent.violated(selected,
+                String.format("Class <%s> not transitively depends on any matching class", selected.getFullName()));
+    }
+
+    private static Set<JavaClass> getDirectDependencies(JavaClass item) {
+        Set<JavaClass> directDependencies = new HashSet<>();
+        for (Dependency dependency : item.getDirectDependenciesFromSelf()) {
+            directDependencies.add(dependency.getTargetClass().getBaseComponentType());
+        }
+        return directDependencies;
+    }
+
+    private class TransitiveDependencyPath {
+        /**
+         * @return the first dependency path to a matching class or empty if there is none
+         */
+        List<JavaClass> findFirstPathToTransitiveDependency(JavaClass clazz) {
+            ImmutableList.Builder<JavaClass> transitivePath = ImmutableList.builder();
+            addDependenciesToPathFrom(clazz, transitivePath, new HashSet<>(allClasses));
+            return transitivePath.build().reverse();
+        }
+
+        private boolean addDependenciesToPathFrom(
+                JavaClass clazz,
+                ImmutableList.Builder<JavaClass> dependencyPath,
+                Set<JavaClass> analyzedClasses
+        ) {
+            if (conditionPredicate.test(clazz)) {
+                dependencyPath.add(clazz);
+                return true;
+            }
+
+            analyzedClasses.add(clazz);
+
+            for (JavaClass directDependency : getDirectDependencies(clazz)) {
+                if (!analyzedClasses.contains(directDependency)
+                        && addDependenciesToPathFrom(directDependency, dependencyPath, analyzedClasses)) {
+                    dependencyPath.add(clazz);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

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

@@ -309,6 +309,11 @@ public static ArchCondition<JavaClass> transitivelyDependOnClassesThat(final Des
                 GET_TRANSITIVE_DEPENDENCIES_FROM_SELF);
     }
 
+    @PublicAPI(usage = ACCESS)
+    public static ArchCondition<JavaClass> transitivelyDependOnAnyClassesThat(final DescribedPredicate<? super JavaClass> predicate) {
+        return new AnyTransitiveDependencyCondition(predicate);
+    }
+
     @PublicAPI(usage = ACCESS)
     public static ArchCondition<JavaClass> onlyDependOnClassesThat(final DescribedPredicate<? super JavaClass> predicate) {
         return new AllDependenciesCondition(

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

@@ -524,6 +524,16 @@ public ClassesShouldConjunction onlyDependOnClassesThat(DescribedPredicate<? sup
         return addCondition(ArchConditions.onlyDependOnClassesThat(predicate));
     }
 
+    @Override
+    public ClassesThat<ClassesShouldConjunction> transitivelyDependOnAnyClassesThat() {
+        return new ClassesThatInternal<>(predicate -> addCondition(ArchConditions.transitivelyDependOnAnyClassesThat(predicate)));
+    }
+
+    @Override
+    public ClassesShouldConjunction transitivelyDependOnAnyClassesThat(DescribedPredicate<? super JavaClass> predicate) {
+        return addCondition(ArchConditions.transitivelyDependOnAnyClassesThat(predicate));
+    }
+
     @Override
     public ClassesThat<ClassesShouldConjunction> transitivelyDependOnClassesThat() {
         return new ClassesThatInternal<>(predicate -> addCondition(ArchConditions.transitivelyDependOnClassesThat(predicate)));

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

@@ -1015,6 +1015,48 @@ public interface ClassesShould {
     @PublicAPI(usage = ACCESS)
     ClassesShouldConjunction onlyDependOnClassesThat(DescribedPredicate<? super JavaClass> predicate);
 
+    /**
+     * Asserts that all classes selected by this rule transitively depend on any matching classes.<br>
+     * This is a much more efficient variant of {@link #transitivelyDependOnClassesThat()} that can be used to detect transitive dependencies in a
+     * huge codebase or to classes in large 3rd-party libraries like the Android SDK.
+     * It focuses on detecting all <strong>direct</strong> dependencies of the selected classes that are themselves matched or have any
+     * transitive dependencies on matched classes. Thus, it doesn't discover all possible dependency paths but stops at the first match to be fast and
+     * resource-friendly.<br>
+     * NOTE: This usually makes more sense the negated way, e.g.
+     * <p>
+     * <pre><code>
+     * {@link ArchRuleDefinition#noClasses() noClasses()}.{@link GivenClasses#should() should()}.{@link #transitivelyDependOnAnyClassesThat()}.{@link ClassesThat#haveFullyQualifiedName(String) haveFullyQualifiedName(String)}
+     * </code></pre>
+     *
+     * NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc...
+     *
+     * @return A syntax element that allows choosing to which classes a transitive dependency should exist
+     */
+    @PublicAPI(usage = ACCESS)
+    ClassesThat<ClassesShouldConjunction> transitivelyDependOnAnyClassesThat();
+
+
+    /**
+     * Asserts that all classes selected by this rule transitively depend on any matching classes.<br>
+     * This is a much more efficient variant of {@link #transitivelyDependOnClassesThat()} that can be used to detect transitive dependencies in a
+     * huge codebase or to classes in large 3rd-party libraries like the Android SDK.
+     * It focuses on detecting all <strong>direct</strong> dependencies of the selected classes that are themselves matched or have any
+     * transitive dependencies on matched classes. Thus, it doesn't discover all possible dependency paths but stops at the first match to be fast and
+     * resource-friendly.<br>
+     * NOTE: This usually makes more sense the negated way, e.g.
+     * <p>
+     * <pre><code>
+     * {@link ArchRuleDefinition#noClasses() noClasses()}.{@link GivenClasses#should() should()}.{@link #transitivelyDependOnAnyClassesThat(DescribedPredicate) transitivelyDependOnAnyClassesThat(myPredicate)}
+     * </code></pre>
+     *
+     * NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc...
+     *
+     * @param predicate Determines which {@link JavaClass JavaClasses} match the dependency target
+     * @return A syntax element that can either be used as working rule, or to continue specifying a more complex rule
+     */
+    @PublicAPI(usage = ACCESS)
+    ClassesShouldConjunction transitivelyDependOnAnyClassesThat(DescribedPredicate<? super JavaClass> predicate);
+
     /**
      * Asserts that all classes selected by this rule transitively depend on certain classes.<br>
      * NOTE: This usually makes more sense the negated way, e.g.