"Packages should never depend on subpackages" rule

[grimsa]

I took some time trying to implement the following architectural rule: "Packages should never depend on sub-packages" (explained here).

It took a few iterations, but the final solution was pretty simple:

A custom DescribedPredicate:

public class ArchUnitExtension {
    public static class JavaClassPredicates {
        public static DescribedPredicate<JavaClass> dependencyOnSubpackages() {
            return DescribedPredicate.describe(
                    "dependency on subpackages",
                    clazz -> {
                        Set<JavaPackage> allSubpackages = clazz.getPackage().getAllSubpackages();
                        return clazz.getDirectDependenciesFromSelf().stream()
                                .map(Dependency::getTargetClass)
                                .map(JavaClass::getPackage)
                                .anyMatch(allSubpackages::contains);
                    }
            );
        }
    }

    private ArchUnitExtension() {
    }
}

and then the rule itself is as simple as:

@ArchTest
private static final ArchRule noClassesShouldDependOnSubpackages = noClasses()
       .should(ArchConditions.have(ArchUnitExtension.JavaClassPredicates.dependencyOnSubpackages()));

This produces violation messages like this:

Architecture Violation [Priority: MEDIUM] - Rule 'no classes should have dependency on subpackages' was violated (25 times):
Class <com.company.domain.Project> has dependency on subpackages in (Project.java:0)
Class <com.company.domain.system.Inverter> has dependency on subpackages in (Inverter.java:0)

---

I'd be happy to open a PR that contributes this (or some part of it) to ArchUnit.
I think the potential contributions (in increasing scope order) are:

1. JavaPackage should have methods for determining the relation between packages (e.g. is package A a descendant/ancestor of package B?). This would help avoid calling JavaPackage#getAllSubpackages for each class in dependencyOnSubpackages predicate, and it could then become something like this:

return DescribedPredicate.describe(
     "dependency on subpackages",
     clazz -> clazz.getDirectDependenciesFromSelf().stream()
          .map(Dependency::getTargetClass)
          .map(JavaClass::getPackage)
          .anyMatch(targetPackage -> clazz.getPackage().isAncestorOf(targetPackage))  // <-- new method
);

2. The new dependencyOnSubpackages could be moved to JavaClass.Predicates in core
3. A new ArchCondition of ArchConditions.have(JavaClass.Predicates.dependencyOnSubpackages())) could be added to ArchConditions in lang
4. The new ArchCondition could be added to the ClassesShould fluent API