Keep loops and conditions out of build.gradle

Ruby has the same trap, and there the instance variables are what catch readers. Most Ruby DSLs run the block with instance_eval, so inside it self is the receiver, bare method calls go there, and instance variables belong to it too. So @config inside the block is not the @config of the code around it, and nothing on the page says so. Same temptation as the Groovy delegate, in a nicer coat.

For anything a stranger will edit, I prefer blocks that yield the object, written as configure do |c| with c.version = ... on each line. Two more characters per line, and every name has a visible owner.

Two more characters per line won't save that reader. Ten lines of delegate magic hurt less than two hundred with explicit receivers, so the length of the script is still the real problem.

I only know Gradle from the outside, but the test part is the bit I'd push hardest. Build logic with a test reads like a spec of what the build does. Without one, the script is the only description, and it's written in the least readable dialect in the repo.

Even one example per custom task helps. Given this input tree, these files come out. A newcomer learns more from that than from any comment above the task. And when someone changes the task, the example breaks instead of the release.

Do the plugin tests in your setup run on every change, or only when someone remembers?

Different ecosystem, but tsconfig files rot the same way. A root config with several layers of extends and per-package overrides is as hard to read as any clever build script, and nobody can say which option wins without running tsc --showConfig. What I settled on there is one base file and one extends per package, nothing deeper.

Since TypeScript 5.0 extends takes an array, with later entries overriding earlier ones, so a package can list two flat bases without a chain. Which option won is still something I only trust tsc --showConfig for.

The part that stung in your build file, a helper in another file swapping the delegate, is what made me fond of how Lua loads config files. The environment is handed over once, at the place the file is loaded, and nowhere else.

local cfg = {}
local chunk = assert(load("version = '1.4.2'", "build.cfg", "t", cfg))
chunk()
print(cfg.version)  --> 1.4.2

Every bare name in that chunk resolves against cfg, and since cfg has no print or require in it, the config can't call anything the loader didn't put there. It's the same trick as a delegate, really, except the swap sits in one line you can find with grep. I was a little surprised how much calmer the scripts I read became once that line was the only place to look.