Groovy has a lot of nice and useful gems.
One of them is the FileTreeBuilder class.
With this class we can create directories and files using a nice DSL with a builder syntax.
The code already reflects the hierarchy of the directory structure, which makes it so more readable.
We can use an explicit way of referring to methods in the FileTreeBuilder class, but there is also support for a more dynamic version, where Groovy's dynamic nature comes to play.
In the first example we use the explicit method names.
We can use the method dir to create directories and the method file to create a file.
We can specify a name for the file and also contents:
Continue reading →
When we write software it is good practice to also write tests.
Either before writing actual code or after, we still need to write tests.
In Grails we can use the test-app command to execute our tests.
If we specify the extra option -continuous Grails will monitor the file system for changes in class files and automatically compiles the code and executes the tests again.
This way we only have to start this command once and start writing our code with tests.
If we save our files, our code gets compiled and tested automatically. We can see the output in the generated HTML report or on the console.
Suppose we have our Grails interactive shell open and we type the following command:
Continue reading →
Because Grails 3 is based on Spring Boot we can use a lot of the functionality of Spring Boot in our Grails applications.
For example we can start Grails 3 with a random available port number, which is useful in integration testing scenario's.
To use a random port we must set the application property server.port to the value 0.
If we want to use the random port number in our code we can access it via the @Value annotation with the expression ${local.server.port}.
Let's create a very simple controller with a corresponding integration test.
The controller is called Sample:
Continue reading →
Gradle 2.13 added a new method to get a property value: findProperty.
This method will return a property value if the property exists or null if the property cannot be found.
Gradle also has the property method to return a property value, but this method will throw an exception if the property is missing.
With the new findProperty method and the Groovy elvis operator (?:) we can try to get a property value and if not found return a default value.
In the following example we have a task that tries to print the value of the properties sampleOld and sampleNew.
We use the findProperty for sampleNew and the property method for sampleOld:
Continue reading →
Since Grails 3 we use Gradle as the build system.
This means we also use Gradle to define dependencies we need.
The default Gradle build file that is created when we create a new Grails application contains the Gradle dependency management plugin via the Gradle Grails plugin.
With the dependency management plugin we can import a Maven Bill Of Materials (BOM) file.
And that is exactly what Grails does by importing a BOM with Grails dependencies.
A lot of the versions of these dependencies can be overridden via Gradle project properties.
To get the list of version properties we write a simple Gradle task to print out the values:
Continue reading →
From May 18-20 myself and Richard attended the Google IO 2016 conference.
We both visited different tracks and have some different experiences we'd like to share.
Here are mine.
Read on about topics in the likes of VR, Progressive Web Apps, and Artificial Intelligence.
For a quick impression have a look at the photo album.
Continue reading →
