...
Be sure to read over the documentation for Building Groovy Projects. A Groovy Maven plugin is a Groovy project, so most of the information there is relevant here as well.
Groovy Mojos
Just like Java-based Mojo's at its simplest, a Groovy Mojo consists of a single class. For more complicated plugins you are free to use as many classes as needed of course, just like Java... and you can even write Java classes too if you need too.
Groovy Mojo implementations are denoted by the @goal Javadoc annotation on the class (er, just like Java). Actually, all of the Javadoc annotations which are supported by Java plugins are also supported by Groovy plugins. This is because, when building a Groovy project, the sub-generator spits out Java sources with Javadocs intact, which the Maven Plugin Plugin then parses for annotations 
A Simple Groovy Mojo
Here is our simple Mojo class which has no parameters and spits out a relatively meaningless string via logging:
...
Lastly, this example mojo extends from org.codehaus.groovy.maven.mojo.GroovyMojo, which is recommended for most Groovy mojos. Of course you can always use org.apache.maven.plugin.AbstractMojo at the cost of some additional bits of happiness which help make your Mojo's groovier.
Building Plugins
Project Definition
Groovy plugins use the same Java plugin descriptor extractor. The Java extractor uses the generated stubs to build the descriptor, so be sure to invoke the generateStubs goal.
...
Once you have your pom setup then you can build the plugin in the normal way via:
| No Format |
|---|
mvn install |
Mojo Parameters
Mojo parameters work exactly the same as they do for Java plugins. Simply define a field in your Mojo implementation and annotate the field with a @parameter Javadoc tag.
...
The main thing to note about Groovy Mojos and parameters, is that fields should be typed so that Maven (or well, Plexus) can inject objects of the proper type. Using the def keyword is the same as typing the field as and Object which Maven will probably still inject just fine, but it won't perform any conversion.
Putting More Groove into your Mojo
Using ant
Using ant allows your Mojo access to any Ant tasks. Groovy Mojo's which extend from GroovyMojo have access to an AntBuilder instance bound to the ant field.
This field is lazily initialized when you first reference it.
...
| Note | ||
|---|---|---|
| ||
The following examples assume that your Mojo implementation has already defined a project property as in:
|
Touching a File
| No Format |
|---|
ant.touch(file: "${project.build.directory}/stamp")
|
Copying Files
| No Format |
|---|
def dir = "${project.build.directory}/backup"
ant.mkdir(dir: dir)
ant.copy(todir: dir) {
fileset(dir: "${project.build.outputDirectoy}") {
include(name: '**/*')
}
}
|
Execute Something
| No Format |
|---|
def propname = 'lsout' ant.exec(executable: '/bin/ls', outputproperty: propname) def value = ant.antProject.properties[propname] |
Using fail()
Most mojos need to report back some failure status, which is normally done by throwing a MojoExecutionException. Groovy Mojos can simply invoke the fail() method, which handles the details of throwing for you.
...
| No Format |
|---|
try {
....
}
catch (Exception e) {
fail("She's the village bicycle! Everybody's had a ride.", e)
}
|
gmaven-archetype-mojo Archetype
To help get Groovy plugins started faster, you can use the gmaven-archetype-mojo. This will create a new project with the basic POM configuration and an example Groovy-based Mojo class to get you started quickly:
...
| No Format |
|---|
example-maven-plugin example-maven-plugin/pom.xml example-maven-plugin/src example-maven-plugin/src/main example-maven-plugin/src/main/groovy example-maven-plugin/src/main/groovy/org example-maven-plugin/src/main/groovy/org/mycompany example-maven-plugin/src/main/groovy/org/mycompany/myproject example-maven-plugin/src/main/groovy/org/mycompany/myproject/example example-maven-plugin/src/main/groovy/org/mycompany/myproject/example/HelloMojo.groovy |
gmaven-plugin Packaging
| Note | ||
|---|---|---|
| ||
TODO |