Builders

// A builder from scratch: method names become nodes, closures become children.
class TagBuilder {
    private StringBuilder out = new StringBuilder()
    private int depth = 0

    def methodMissing(String name, args) {
        def attrs = args.find { it instanceof Map } ?: [:]
        def body = args.find { it instanceof Closure }
        def text = args.find { it instanceof CharSequence }
        def attrText = attrs.collect { k, v -> " ${k}=\"${v}\"" }.join()
        out << '  ' * depth << "<${name}${attrText}>"
        if (body) {
            out << '\n'
            depth++
            body.delegate = this                       // nested names resolve on the builder
            body.resolveStrategy = Closure.DELEGATE_FIRST
            body()
            depth--
            out << '  ' * depth
        } else if (text) {
            out << text
        }
        out << "</${name}>\n"
        this
    }

    String toString() { out }
}

def html = new TagBuilder()
html.greenhouse(name: 'Home') {
    zone(id: 'bench') {
        plant('Tomato')
        plant('Basil')
    }
}
print html

<greenhouse name="Home">
  <zone id="bench">
    <plant>Tomato</plant>
    <plant>Basil</plant>
  </zone>
</greenhouse>

import groovy.xml.MarkupBuilder
import groovy.xml.StreamingMarkupBuilder

def writer = new StringWriter()
def xml = new MarkupBuilder(writer)
xml.zones {
    zone(id: 'bench', area: 2.5) {
        plant(name: 'Tomato', 'needs a stake')
        plant(name: 'Basil')
    }
    zone(id: 'bed')
}
println writer

def streamed = new StreamingMarkupBuilder().bind {
    zones {
        zone(id: 'bench') { plant('Tomato') }
        mkp.comment('written lazily')
    }
}
println streamed.toString()

<zones>
  <zone id='bench' area='2.5'>
    <plant name='Tomato'>needs a stake</plant>
    <plant name='Basil' />
  </zone>
  <zone id='bed' />
</zones>
<zones><zone id='bench'><plant>Tomato</plant></zone><!--written lazily--></zones>

import groovy.xml.DOMBuilder
import groovy.xml.SAXBuilder
import groovy.xml.StaxBuilder
import groovy.xml.dom.DOMCategory
import javax.xml.stream.XMLOutputFactory

// SAX events for a handler
class LogHandler extends org.xml.sax.helpers.DefaultHandler {
    List events = []
    void startElement(String uri, String localName, String qName, org.xml.sax.Attributes atts) { events << "start:${localName}" }
    void endElement(String uri, String localName, String qName) { events << "end:${localName}" }
}
def handler = new LogHandler()
new SAXBuilder(handler).zone { plant() }
println handler.events

// StAX writer
def writer = new StringWriter()
def stax = new StaxBuilder(XMLOutputFactory.newInstance().createXMLStreamWriter(writer))
stax.zone(id: 'bench') {
    plant('Tomato')
}
println writer

// W3C DOM tree built and read back
def doc = DOMBuilder.newInstance().zones {
    zone(id: 'bench') { plant('Tomato'); plant('Basil') }
}
println doc.tagName
use(DOMCategory) {
    println doc.zone.plant.collect { it.text() }
}

[start:zone, start:plant, end:plant, end:zone]
<?xml version='1.0' encoding='UTF-8'?><zone id="bench"><plant>Tomato</plant></zone>
zones
[Tomato, Basil]

def nodes = new NodeBuilder().zones {
    zone(id: 'bench', area: 2.5) {
        plant(name: 'Tomato')
        plant(name: 'Basil')
    }
    zone(id: 'bed') {
        plant(name: 'Carrot')
    }
}

println nodes.getClass().name
println nodes.zone.plant.'@name'.join(', ')
println nodes.zone.find { it.'@id' == 'bed' }.plant.size()
println nodes.zone[0].attributes()
println nodes.zone[0].plant.'@name'

groovy.util.Node
Tomato, Basil, Carrot
1
[id:bench, area:2.5]
[Tomato, Basil]

import groovy.json.JsonBuilder
import groovy.json.JsonOutput
import groovy.json.StreamingJsonBuilder

def json = new JsonBuilder()
json.zone {
    id 'bench'
    plants(['Tomato', 'Basil'])
    sensors {
        temperature 21.5
    }
}
println json.toString()
json.content.zone.id = 'bench-2'                      // an in-memory structure can still be changed
println JsonOutput.prettyPrint(json.toString())

def out = new StringWriter()
def streaming = new StreamingJsonBuilder(out)
streaming.zone(id: 'bed') {
    plants(['Carrot'])
}
println out

{"zone":{"id":"bench","plants":["Tomato","Basil"],"sensors":{"temperature":21.5}}}
{
    "zone": {
        "id": "bench-2",
        "plants": [
            "Tomato",
            "Basil"
        ],
        "sensors": {
            "temperature": 21.5
        }
    }
}
{"zone":{"id":"bed","plants":["Carrot"]}}

def root = File.createTempDir('greenhouse', '')
try {
    def tree = new FileTreeBuilder(root)
    tree.dir('data') {
        file('plants.json', '[{"name":"Tomato"}]')
        dir('archive') {
            file('2026.csv', 'sensor,temperature\nT1,21.5\n')
        }
    }
    tree.config {                                  // shorthand: names become directories
        'zones.yaml'('bench: {}')
    }
    tree.file('README.txt', 'generated')           // top level

    def files = []
    root.eachFileRecurse { f -> if (f.isFile()) files << root.toPath().relativize(f.toPath()).toString() }
    println files.sort()
    assert new File(root, 'data/archive/2026.csv').readLines()[1] == 'T1,21.5'
} finally {
    root.deleteDir()
}

[README.txt, config/zones.yaml, data/archive/2026.csv, data/plants.json]

package greenhouse

class Zone {
    String name
    List plants = []
    Bed bed
}
class Plant {
    String name
    Zone zone
}
class Bed {
    String soil
}

def builder = new ObjectGraphBuilder()
builder.classLoader = this.class.classLoader
builder.classNameResolver = 'greenhouse'

def zone = builder.zone(name: 'bench') {
    bed(id: 'peat', soil: 'peat')
    plant(name: 'Tomato')
    plant(name: 'Basil')
}
assert zone instanceof Zone
println zone.plants*.name
println zone.plants.every { it.zone.is(zone) }          // the parent property was filled in
println zone.bed.soil

def two = builder.zone(name: 'bed') {
    plant(name: 'Carrot', zone: zone)                    // attributes can also reference objects
}
println two.plants[0].zone.name

[Tomato, Basil]
true
peat
bed

import groovy.cli.commons.CliBuilder

def cli = new CliBuilder(usage: 'groovy water [options] zone...', header: 'Waters greenhouse zones:')
cli.m(longOpt: 'minutes', args: 1, argName: 'n', type: int, defaultValue: '5', 'minutes per zone')
cli.d(longOpt: 'dry-run', 'print what would be watered')
cli.h(longOpt: 'help', 'show this help')

def options = cli.parse('-m 10 --dry-run bench bed'.split())
println options.m
println options.d
println options.arguments()

def defaults = cli.parse(['bench'])
println defaults.m                       // default value applies when absent
println defaults.hasOption('m')

cli.usage()

10
true
[bench, bed]
5
false
usage: groovy water [options] zone...
Waters greenhouse zones:
 -d,--dry-run       print what would be watered
 -h,--help          show this help
 -m,--minutes <n>   minutes per zone

import groovy.cli.Option
import groovy.cli.Unparsed
import groovy.cli.commons.CliBuilder

interface WaterOptions {
    @Option(shortName = 'm', description = 'minutes per zone', defaultValue = '5') int minutes()
    @Option(shortName = 'd', description = 'print only') boolean dryRun()
    @Unparsed(description = 'zones') List<String> zones()
}

def options = new CliBuilder(usage: 'water').parseFromSpec(WaterOptions, '--minutes 8 -d bench bed'.split())
println options.minutes()
println options.dryRun()
println options.zones()

class WaterConfig {
    @Option(shortName = 'm', description = 'minutes per zone') int minutes = 5
    @Unparsed List<String> zones
}
def config = new WaterConfig()
new CliBuilder().parseFromInstance(config, ['-m', '3', 'bench'] as String[])
println "${config.minutes} ${config.zones}"

8
true
[bench, bed]
3 [bench]

groovy -cp picocli-4.7.7.jar water.groovy

import groovy.cli.picocli.CliBuilder

def cli = new CliBuilder(name: 'water', usage: 'water [options] zone...')
cli.m(longOpt: 'minutes', args: 1, type: int, defaultValue: '5', 'minutes per zone')
cli.d(longOpt: 'dry-run', 'print what would be watered')

def options = cli.parse('-m 10 --dry-run bench bed'.split())
println options.m
println options.d
println options.arguments()
cli.usage()

10
true
[bench, bed]
Usage: water [options] zone...
  -d, --dry-run         print what would be watered
  -m, --minutes=PARAM   minutes per zone

import groovy.ant.AntBuilder

def root = File.createTempDir('ant', '')
try {
    new File(root, 'src').mkdirs()
    new File(root, 'src/a.csv').text = 'T1,21.5\n'
    new File(root, 'src/b.csv').text = 'T2,22.0\n'
    new File(root, 'src/notes.txt').text = 'skip me\n'

    def ant = new AntBuilder()
    ant.project.buildListeners.each { it.messageOutputLevel = 1 }   // only errors and warnings (hides [mkdir]/[copy])
    ant.project.baseDir = root                    // resolve relative paths against the temp directory
    ant.sequential {
        echo('copying csv files')
        mkdir(dir: 'backup')
        copy(todir: 'backup') {
            fileset(dir: 'src') { include(name: '*.csv') }
        }
    }
    println new File(root, 'backup').list().sort()

    def scanner = ant.fileScanner {
        fileset(dir: 'src') { include(name: '*.txt') }
    }
    println scanner.collect { it.name }
} finally {
    root.deleteDir()
}

     [echo] copying csv files
[a.csv, b.csv]
[notes.txt]

System.setProperty('java.awt.headless', 'true')
import groovy.swing.SwingBuilder

def swing = new SwingBuilder()
def panel = swing.panel(name: 'controls') {
    borderLayout()
    label(text: 'Bench pump', constraints: java.awt.BorderLayout.NORTH)
    button(id: 'start', text: 'Start', constraints: java.awt.BorderLayout.SOUTH,
           actionPerformed: { println 'start pressed' })
}

println panel.getClass().simpleName
println panel.components*.class*.simpleName
println swing.start.text                        // id: registers the component as a builder variable
swing.start.doClick()                           // fires the listener without a screen

JPanel
[JLabel, JButton]
Start
start pressed

import groovy.jmx.builder.JmxBuilder
import java.lang.management.ManagementFactory
import javax.management.ObjectName

class Pump {
    int minutes = 5
    boolean running
    void start() { running = true }
}

def pump = new Pump()
def jmx = new JmxBuilder()                       // uses the platform MBeanServer by default
jmx.export {
    bean(target: pump, name: 'greenhouse:type=Pump', attributes: '*', operations: '*')
}

def server = ManagementFactory.platformMBeanServer
def name = new ObjectName('greenhouse:type=Pump')
println server.isRegistered(name)
println server.getMBeanInfo(name).attributes*.name     // JMX capitalises the names
println server.getAttribute(name, 'Minutes')
server.invoke(name, 'start', null, null)
println pump.running
server.unregisterMBean(name)

true
[Minutes, Running]
5
true