How to eliminate cut-and-paste closures when using JSONBuilder

Does anyone know of a way to avoid repeating a closure when emitting the same object more than once using the latest version of the Grails JSONBuilder?

I have a Group domain object that contains sets of Members and Leaders. I would like to find a way to emit a person without having to cut and paste the closure.

    def builder = new JSONBuilder() 
    def result = builder.build {
        array {
            Group.list().each { Group group ->
                g = {
                    id = group.id
                    name = group.name

                    members = array {
                        group.members?.person?.sort().each { Person person ->
                            m = {  // Person closure copy #1
                                id = person.id
                                firstName = person.firstName
                                lastName = person.lastName
                            }
                        }
                    }

                    leaders = array {
                        group.leaders?.person?.sort().each { Person person ->
                            l = {   // Person closure copy #2
                                id = person.id
                                firstName = person.firstName
                                lastName = person.lastName
                            }
                        }
                    }
                }
            }
        }
    }

I have tried defining the closure separately but that leads to errors such as: exception: No such property: id for class:.

---

Some notes:

1) The domain objects in the example are greatly simplified. I'm using JSONBuilder instead of render Group.list() as JSON or render Group.list().encodeAsJS开发者_C百科ON because I need to control what parts of my objects are encoded.

2) I'll accept authoritative answers that explain why this can't be done.

---

After repeated failures using closures, I have a solution. It doesn't use a closure directly but instead uses a closure that returns a map.

class Person { 
    ...

    def toMap = {
        def map = [:]
        map["id"] = this.id
        map["firstName"] = this.firstName
        map["lastName"] = this.lastName
        return map
    }
}

def builder = new JSONBuilder() 
def result = builder.build {
    array {
        Group.list().each { Group group ->
            g = {
                id = group.id
                name = group.name

                members = array {
                    group.members?.person?.sort().each { Person person -> 
                        m(person.toMap())
                    }
                }

                leaders = array {
                    group.leaders?.person?.sort().each { Person person ->
                        l(person.toMap())
                    }
                }
            }
        }
    }
}

The m(person.toMap()) syntax isn't intuitive but it works and allows me to avoid repeating myself. This blog entry provides the details and explains the origin of the current Grails JSONBuilder.

---

You can execute another closure in the same "context" by setting the "delegate" for the closure. Closures aren't multi-thread safe (only one delegate at a time) so you will have to clone the closure each time if the closures are shared in a singleton class or static variable.

This is just an idea of refactoring the code, it might not work (I didn't test it). You can replace assignment (=) with "setProperty" and DSL method calls with "invokeMethod" if you have to dynamicly decide the property name or method name in the DSL. (reference http://groovy.codehaus.org/api/groovy/lang/Closure.html)

def personClosure = { Person person, varname ->
    setProperty(varname, {
        id = person.id
        firstName = person.firstName
        lastName = person.lastName
    })
}

def groupMembersClosure = { memberList, memberListVarName, memberVarName ->
    personClosure.delegate = delegate
    setProperty(memberListVarName, array {
        memberList?.person?.sort().each personClosure, memberVarName
    })
}

def builder = new JSONBuilder()
def result = builder.build {
    array {
        Group.list().each { Group group ->
            g = {
                id = group.id
                name = group.name

                groupMembersClosure.delegate = delegate

                groupMembersClosure(group.members, 'members', 'm')
                groupMembersClosure(group.leaders, 'leaders', 'l')
            }
        }
    }
}