The base of a groovy DSL is the Script class or the DelegatingScript. To provide some functions to your DSL, you define them in this class, implement the missingMethod or enhance the metaclass. No matter which way you choose, it blows up your class with rising amount of functions. So after some time you might want to restructure your code. For some other reason you might want to enable other people to enhance the DSL without touching the base DSL class.
The idea is to provide a class that can be instantiated in you DSL with a create-method.
1. Define a marker interface to find the plugin class (you can do this with annotations as well)
Every class implementing this marker interface will be instantiable in your DSL
|
1 |
interface Instantiable {} |
2. A class that enhances your DSL
We’ll have a Car class that has only one field describing the color of our car
|
1 2 3 4 5 6 7 |
class Car implements Instantiable { def color = "blue" def printColor() { println color } } |
3. The actual DSL-backing class
Now we’ll go to the bone. As mentioned above, there are several ways to enhance the DSL class with new functions. In this sample we’ll add new functions by enhancing DSL’s metaClass.
We’ll have two functions to get an instance of Car: newCar and newCarWith.
newCar is calling the Default-Constructor without arguments. newCarWith calls the “Named” Default-Constructor with a map. To achieve this, there are two closures defined in line 3 and 4. First one with two params (actual class and the map) and one with a single param (only the class to instantiate).
Now we need to find the classes to instantiate. I used the reflections-API to find all classes implementing the Instantiable interface (line 6). In this sample only classes of the package de.metacode.dslplugin are scanned. You can scann the whole known classes as well.
Line 7 and 8 is where the magic happens: Two new methods are added to metaClass. Note the curry-call on the newInstance-closures. What this does is called currying (or Schönfinkeln). It reduces a function with n arguments to a function with n-1 arguments. In this case curry generates a new closure without the first parameter Class clazz. So we have one closure without any parameter and another one with a map.
|
1 2 3 4 5 6 7 8 9 10 11 |
class DSL { static { def newInstanceWithArgs = { Class clazz, Map args -> clazz.newInstance(args) } def newInstance = { Class clazz -> clazz.newInstance() } new Reflections("de.metacode.dslplugin").getSubTypesOf(Instantiable).each { Class clazz -> DSL.metaClass."new${clazz.simpleName}With" = newInstanceWithArgs.curry(clazz) DSL.metaClass."new${clazz.simpleName}" = newInstance.curry(clazz) } } } |
4. Writing some DSL-code
Now we can instantiate the Car without params or with named params:
|
1 2 3 4 5 |
blueCar = newCar() //blue is the default value blueCar.printColor() redCar = newCarWith color: 'red' redCar.printColor() |
The output is
|
1 2 |
blue red |
That’s it
Here you’ll find executable wired-together code:
https://gist.github.com/codeeraser/31d031cd921e168049ac
You’ll might get some issues with reflections-API when running this code via command-line. To get reflections work like one would expect can be pretty annoying (see stackoverflow…). The shortest way is to run the sample in an IDE.