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,136 @@
+package com.tngtech.archunit.lang.conditions;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.StringJoiner;
+
+import com.google.common.collect.Lists;
+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;
+
+public class AnyTransitiveDependencyCondition extends ArchCondition<JavaClass> {
+
+    private final DescribedPredicate<? super JavaClass> conditionPredicate;
+    private final JavaClassTransitiveDependencyPath transitiveDependencyPath;
+    private Collection<JavaClass> allClasses;
+
+    public AnyTransitiveDependencyCondition(DescribedPredicate<? super JavaClass> conditionPredicate) {
+        super("transitively depend on any classes that " + conditionPredicate.getDescription());
+
+        this.conditionPredicate = checkNotNull(conditionPredicate);
+        this.transitiveDependencyPath = new JavaClassTransitiveDependencyPath();
+    }
+
+    @Override
+    public void init(Collection<JavaClass> allObjectsToTest) {
+        this.allClasses = allObjectsToTest;
+    }
+
+    @Override
+    public void check(JavaClass item, ConditionEvents events) {
+        for (JavaClass dependency : getDirectDependencies(item)) {
+            if (!allClasses.contains(dependency)) {
+                List<JavaClass> dependencyPath = transitiveDependencyPath.findFirstPathToTransitiveDependency(dependency);
+                if (!dependencyPath.isEmpty()) {
+                    events.add(new TransitivePathFoundEvent(item, dependencyPath));
+                }
+            }
+        }
+    }
+
+    private class JavaClassTransitiveDependencyPath {
+        /**
+         * @return the first dependency path to a matching class or empty if there is none
+         */
+        List<JavaClass> findFirstPathToTransitiveDependency(JavaClass clazz) {
+            LinkedList<JavaClass> transitivePath = new LinkedList<>();
+            addDependenciesToPathFrom(clazz, transitivePath, new HashSet<>());
+            return Collections.unmodifiableList(transitivePath);
+        }
+
+        private boolean addDependenciesToPathFrom(
+                JavaClass clazz,
+                LinkedList<JavaClass> dependencyPath,
+                Set<JavaClass> analyzedClasses
+        ) {
+            if (conditionPredicate.test(clazz)) {
+                dependencyPath.addFirst(clazz);
+                return true;
+            }
+
+            analyzedClasses.add(clazz);
+
+            for (JavaClass directDependency : getDirectDependencies(clazz)) {
+                if (!allClasses.contains(directDependency)
+                        && !analyzedClasses.contains(directDependency)
+                        && addDependenciesToPathFrom(directDependency, dependencyPath, analyzedClasses)) {
+                    dependencyPath.addFirst(clazz);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+
+    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 static class TransitivePathFoundEvent implements ConditionEvent {
+        private final JavaClass selected;
+        private final String message;
+
+        public TransitivePathFoundEvent(JavaClass selected, List<JavaClass> transitivePath) {
+            this.selected = selected;
+
+            String messageStr =
+                    String.format("Class <%s> accesses <%s>", selected.getFullName(), transitivePath.get(0).getFullName());
+
+            if (transitivePath.size() > 1) {
+                messageStr += " which transitively accesses e.g. ";
+                StringJoiner joiner = new StringJoiner("> <- <", "<", ">");
+                for (JavaClass dependencyTarget : Lists.reverse(transitivePath)) {
+                    joiner.add(dependencyTarget.getFullName());
+                }
+                messageStr += joiner.toString();
+            }
+            message = messageStr;
+        }
+
+        @Override
+        public boolean isViolation() {
+            return false;
+        }
+
+        @Override
+        public void addInvertedTo(ConditionEvents events) {
+            events.add(SimpleConditionEvent.violated(selected, message));
+        }
+
+        @Override
+        public List<String> getDescriptionLines() {
+            return Collections.singletonList(message);
+        }
+
+        @Override
+        public void handleWith(Handler handler) {
+            handler.handle(Collections.singletonList(selected), message);
+        }
+    }
+}

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.