package dev.caskeleton.buildlogic.architecture; import dev.caskeleton.buildlogic.ModuleRegistry; import java.io.File; import java.nio.file.Path; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.TreeSet; import org.gradle.api.Plugin; import org.gradle.api.Project; import org.gradle.api.artifacts.Configuration; import org.gradle.api.artifacts.ProjectDependency; import org.gradle.api.artifacts.result.ResolvedComponentResult; import org.gradle.api.provider.Provider; import org.gradle.api.tasks.SourceSet; import org.gradle.api.tasks.SourceSetContainer; public final class ArchitecturePlugin implements Plugin { private static final List PRODUCTION_DECLARATIONS = List.of("api", "implementation", "compileOnly", "runtimeOnly"); /** The registry, relative to the repository root. */ public static final String REGISTRY = "config/architecture/modules.json"; @Override public void apply(Project project) { // One build, rooted at the repository root: the registry is the root's, and every source_path // is relative to it (the template's main build sits in src/, which is why its copy reads the // registry relative to the parent). Project root = project.getRootProject(); File repositoryRoot = root.getProjectDir(); File registryFile = new File(repositoryRoot, REGISTRY); ModuleRegistry registry = ModuleRegistry.read(registryFile, repositoryRoot); List modules = registry.modulesForBuild("main"); List registryViolations = registryViolations(registry, modules); var clean = project .getTasks() .register( "verifyCleanArchitectureDependencies", VerifyCleanArchitectureDependenciesTask.class, task -> { task.setGroup("verification"); task.setDescription("Verifies Clean Architecture project dependency direction."); task.getRegistryFile().fileValue(registryFile); task.getRegistryViolations().set(registryViolations); task.getUnregisteredBuildScripts() .set(registry.unregisteredBuildScripts(root.getProjectDir())); }); var ignoredSources = project .getTasks() .register( "verifyNoIgnoredSourcePackages", VerifyNoIgnoredSourcePackagesTask.class, task -> { task.setGroup("verification"); task.setDescription( "Fails when a Java source file lives in a package that Git ignores or would" + " ignore."); task.getBuildRoot().set(root.getLayout().getProjectDirectory()); }); project .getGradle() .projectsEvaluated( ignored -> { Set declaredModules = new HashSet<>(); root.getSubprojects().stream() .filter(sub -> sub.getChildProjects().isEmpty()) .forEach(sub -> declaredModules.add(sub.getPath().replaceFirst("^:", ""))); // One task per module, registered in the project that owns the configurations. The // root task used to walk every other project and resolve its `compileClasspath`, // which asks Gradle for state another project holds the lock on — with // `org.gradle.parallel=true` that is a hard failure, and it is why the flag was // turned off instead of the verification moved. List moduleTaskPaths = new ArrayList<>(); for (ModuleRegistry.Module module : modules) { Project owner = root.project(module.gradlePath()); Set allowed = new HashSet<>(); for (String dependencyId : module.allowedDependencies()) { ModuleRegistry.Module dependency = registry.byId(dependencyId); if (dependency != null) { allowed.add(dependency.gradlePath().replaceFirst("^:", "")); } } Set declaredEdges = declaredProjectEdges(owner); Provider compileClasspathRoot = owner .getConfigurations() .getByName("compileClasspath") .getIncoming() .getResolutionResult() .getRootComponent(); String moduleName = module.gradlePath().replaceFirst("^:", ""); owner .getTasks() .register( "verifyModuleDependencyDirection", VerifyModuleDependencyDirectionTask.class, task -> { task.setGroup("verification"); task.setDescription( "Verifies this module's declared and compile-visible project edges" + " against the architecture registry."); task.getModuleName().set(moduleName); task.getAllowedDependencies().set(allowed); task.getDeclaredProjectEdges().set(declaredEdges); task.getCompileClasspathRoot().set(compileClasspathRoot); }); moduleTaskPaths.add(module.gradlePath() + ":verifyModuleDependencyDirection"); } clean.configure( task -> { task.getDeclaredModules().set(declaredModules); task.getGovernedModules() .set( modules.stream() .map(module -> module.gradlePath().replaceFirst("^:", "")) .toList()); task.dependsOn(moduleTaskPaths); }); // Every source set of every project — testFixtures, integrationTest, systemTest and // the sample included — because a file Git drops is lost whichever lane owns it. // Directories under a build directory are generated and never committed. List sourceRoots = new ArrayList<>(); for (Project sub : root.getSubprojects()) { SourceSetContainer sourceSets = sub.getExtensions().findByType(SourceSetContainer.class); if (sourceSets == null) { continue; } Path buildDirectory = sub.getLayout().getBuildDirectory().get().getAsFile().toPath(); for (SourceSet sourceSet : sourceSets) { for (File sourceRoot : sourceSet.getJava().getSrcDirs()) { if (!sourceRoot.toPath().startsWith(buildDirectory)) { sourceRoots.add(sourceRoot); } } } } ignoredSources.configure(task -> task.getSourceRoots().from(sourceRoots)); }); project .getTasks() .register( "architectureCheck", task -> { task.setGroup("verification"); task.setDescription("Runs the build's architecture invariants."); task.dependsOn(clean, ignoredSources); }); } /** * This module's declared {@code project(...)} edges, read while the owning project is configured. * *

Read here rather than in the task action: a {@link Configuration} cannot be stored in the * configuration cache, and every declaration this reads is final by {@code projectsEvaluated}. */ private static Set declaredProjectEdges(Project owner) { Set edges = new TreeSet<>(); for (String name : PRODUCTION_DECLARATIONS) { Configuration configuration = owner.getConfigurations().findByName(name); if (configuration == null) { continue; } configuration .getDependencies() .withType(ProjectDependency.class) .forEach(dependency -> edges.add(dependency.getPath().replaceFirst("^:", ""))); } return edges; } private static List registryViolations( ModuleRegistry registry, List modules) { List violations = new ArrayList<>(); for (ModuleRegistry.Module module : modules) { for (String dependencyId : module.allowedDependencies()) { if (dependencyId.equals(module.id())) { violations.add("'" + module.id() + "' declares itself as an allowed dependency"); continue; } ModuleRegistry.Module dependency = registry.byId(dependencyId); if (dependency == null) { violations.add( "'" + module.id() + "' allows unknown dependency id '" + dependencyId + "'"); } else if (!dependency.buildName().equals(module.buildName())) { violations.add( "'" + module.id() + "' allows cross-build dependency id '" + dependencyId + "'"); } } } return List.copyOf(violations); } }