Question

I’d like to create a DSL with syntax like:

Graph.make {
    foo {
        bar()
        definedMethod1() // isn't missing!
    }
    baz()
}

Where when the handler for this tree encounters the outermost closure, it creates an instance of some class, which has some defined methods and also its own handler for missing methods.

I figured this would be easy enough with some structure like:

public class Graph {
    def static make(Closure c){
        Graph g = new Graph()
        c.delegate = g
        c()
    }

    def methodMissing(String name, args){
        println "outer " + name
        ObjImpl obj = new ObjImpl(type: name)
        if(args.length > 0 && args[0] instanceof Closure){
            Closure closure = args[0]
            closure.delegate = obj
            closure()
        }
    }

    class ObjImpl {
        String type
        def methodMissing(String name, args){
            println "inner " + name
        }
        def definedMethod1(){ 
                println "exec'd known method"
        }
    }
}

But the methodMissing handler interprets the entire closure inside Graph rather than delegating the inner closure to ObjImpl, yielding output:

outer foo
outer bar
exec'd known method
outer baz

How do I scope the missing method call for the inner closure to the inner object that I create?

Answer 1

There are at least two problems with this approach:

1. Defining ObjImpl within the same context as Graph means that any missingMethod call will hit Graph first

2. Delegation appears to happen locally unless a resolveStrategy is set, e.g.:

   closure.resolveStrategy = Closure.DELEGATE_FIRST