This is how you can implement a gradle-ish behavior of executing a designated method before everything else in a dsl script (gradle executes doFirst{} first). Actually, I have no clue how gradle does it. This approach is about manipulating the AST with an implementation of CompilationCustomizer. I’ll describe two variations. First, how to execute the script twice, e.g. to set up an environment and execute the actual code sometimes later. And than how you can re-order the statements before execution. It’ll be helpful if you know about how AST transformations work (if you don’t, see the links at the end of this article).
Let’s say we have a DSL script like this:
|
1 2 3 4 5 6 7 |
println "this is text that will not be printed out in first line!" doFirst { println "First things first: e.g. setting up environment" } doStuff { println "doing some stuff now" } println "That's it!" |
First variation:
We’ll handle the DSL using DelegatingScript. The is the delegate for the first run (only doFirst will be executed):
|
1 2 3 4 5 |
class DoFirstProcessor { def doFirst(Closure c) { c() } } |
For the second run this is doing everything else:
|
1 2 3 4 5 6 7 8 9 |
class TheRestProcessor { def doStuff(Closure c) { c() } def methodMissing(String name, args) { //nothing to do } } |
At this point we’ve got everything we need to execute the DSL. Now comes the AST transformation part. The following CompilerCustomizer removes every statement from the AST except a designated method. Because there can only be one (method), this is called the HighlanderCustomizer 😉
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
class HighlanderCustomizer extends CompilationCustomizer { def methodName HighlanderCustomizer(def methodName) { super(CompilePhase.SEMANTIC_ANALYSIS) this.methodName = methodName } @Override void call(SourceUnit sourceUnit, GeneratorContext generatorContext, ClassNode classNode) throws CompilationFailedException { def methods = classNode.getMethods() methods.each { MethodNode m -> m.code.each { Statement st -> if (!(st instanceof BlockStatement)) { return } def removeStmts = [] st.statements.each { Statement bst -> if (bst instanceof ExpressionStatement) { def ex = bst.expression if (ex instanceof MethodCallExpression) { if (!ex.methodAsString.equals(methodName)) { removeStmts << bst } } else { removeStmts << bst } } else { removeStmts << bst } } st.statements.removeAll(removeStmts) } } } } |
Bring it all together:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
def cc = new CompilerConfiguration() cc.addCompilationCustomizers new HighlanderCustomizer("doFirst") cc.scriptBaseClass = DelegatingScript.class.name def doFirstShell = new GroovyShell(new Binding(), cc) def doFirstScript = doFirstShell.parse dsl doFirstScript.setDelegate new AllStuffProcessor() doFirstScript.run() // Next run could be sometimes later. This will handle everything else than doFirst: cc.compilationCustomizers.clear() // no customizer needed for second run def shell = new GroovyShell(new Binding(), cc) def script = shell.parse dsl script.setDelegate new TheRestProcessor() script.run() |
The console output should look like this:
|
1 2 3 4 |
First things first: e.g. setting up environment this is text that will not be printed out in first line! doing some stuff now That's it! |
Second variation:
Now the DSL will not be executed in two steps but rather in one single run. We’ll use a CompilationCustomizer again. This time the customizer finds a designated method call and changes the order of execution.
Our Delegate (this time only one is needed):
|
1 2 3 4 5 6 7 8 9 10 11 12 |
class AllStuffProcessor { def doFirst(Closure c) { c() } def doStuff(Closure c) { c() } def methodMissing(String name, args) { //nothing to do } } |
The ReOrderCustomizer:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
class ReOrderCustomizer extends CompilationCustomizer { def methodName ReOrderCustomizer(def methodName) { super(CompilePhase.SEMANTIC_ANALYSIS) this.methodName = methodName } @Override void call(SourceUnit sourceUnit, GeneratorContext generatorContext, ClassNode classNode) throws CompilationFailedException { def methods = classNode.getMethods() methods.each { MethodNode m -> m.code.each { Statement st -> if (!(st instanceof BlockStatement)) { return } def doFirstStmt st.statements.each { Statement bst -> if (bst instanceof ExpressionStatement) { def ex = bst.expression if (ex instanceof MethodCallExpression) { if (ex.methodAsString.equals(methodName)) { doFirstStmt = bst } } } } if (doFirstStmt) { st.statements.remove(doFirstStmt) st.statements.add(0, doFirstStmt) } } } } } |
Bring it all together:
|
1 2 3 4 5 6 7 8 |
def cc = new CompilerConfiguration() cc.addCompilationCustomizers new ReOrderCustomizer("doFirst") cc.scriptBaseClass = DelegatingScript.class.name def shell = new GroovyShell(new Binding(), cc) def script = shell.parse dsl script.setDelegate new AllStuffProcessor() script.run() |
Additionally, one should check that the designated method appears only once in the DSL script.
To understand how the AST looks like, just debug the customizer’s call method.
This article is based on a question I postet on Stackoverflow: http://stackoverflow.com/questions/29967886/groovy-dsl-how-can-i-let-two-delegating-classes-handle-different-parts-of-a-dsl
Links:
Great example of using Groovy to implement a DSL: https://groovy.codeplex.com/wikipage?title=Guillaume%20Laforge’s%20%22Mars%20Rover%22%20tutorial%20on%20Groovy%20DSL’s
About CompilationCustomizer: http://www.jroller.com/melix/entry/customizing_groovy_compilation_process
AST transformation workshop: http://melix.github.io/ast-workshop/
Joe’s series of AST articles: http://joesgroovyblog.blogspot.de