Sometime we need to define a project property in our Gradle build file for which the value must be evaluated later than the assignment.
We can do this in different ways in Gradle.
For example for a String type property we can rely on Groovy's support for lazy String evaluation.
If the property is of a different type we can use Closure to define the value.
The Closure code is not executed during the configuration phase directly, but we can write code to invoke the Closure at the right moment and get the value.
Finally we can use the afterEvaluate method of the Project class to define a lazy property.
Let's look at the different options we have with some code samples.
First we look at a lazy String property.
We illustrate this with an example of a multi-project build with the following layout:
Continue reading →
Als JDriven ervaren we elke dag hoe schaars het talent is dat nodig is om onze klanten optimaal te ondersteunen.
Deels omdat we op zoek zijn naar echte specialisten maar vooral omdat we verwachten dat collega’s een passie hebben voor hun vak en erg gemotiveerd zijn om mooie dingen te maken.
Deze passie is voor ons essentieel en wat mij betreft is dit de basis van succesvol software ontwikkelen oftewel het moderne maken.
Het ontwikkelen van een specialisme vergt tijd.
Het vindt eigenlijk pas plaats tijdens een studie en wordt continu ontwikkeld tijdens je verdere carrière.
Maar de passie voor het vak, dat wat mijn collega’s uniek maakt, wordt al veel eerder gelegd.
Zonder uitzondering blijkt het ontstaan van deze passie te herleiden naar één of twee toevallige gebeurtenissen in hun jeugd: een ouder met een passie voor electronica, een vriendje (of vriendinnetje) met een computer etc..
Zelf heb ik het geluk gehad dat ik ook als kind de passie voor het maken heb mee gekregen.
Door mijn opa al timmerend aan het werk te zien; een speelgoed tractor, een bed, een klimrek.
Daarna werd het al snel mee timmeren en samen een vogelhuisje maken.
Toen er via het werk van mijn vader een computer bij ons in huis kwam kreeg ik de kans om met het moderne maken in aanraking te komen.
Samen met mijn vader de eerste programma’s schrijven zoals een muziekspeler, een spelletje en een catalogus om mijn muziek-verzameling in vast te leggen.
De optelsom van deze ervaringen is van grote invloed geweest op mijn toekomst.
Niet omdat ik destijds uitstekend heb leren programmeren, maar omdat mijn passie voor het vak daar is ontstaan en ik me op basis van die passie verder heb kunnen en mogen ontwikkelen.
Continue reading →
Today I'll show how you can create a simple stubserver with Drakov.
If you do some frontend programming, you've probably already installed npm (Node Package Manager), otherwise here is how you install that.
Then with npm you can install Drakov.
$ sudo npm install -g drakov
Continue reading →
In this post I will show you how to integrate the Antlr4 parser generator in your Java project to generate a parser and use the parser to parse simple mathematical expressions.
It’s a good starting point if you need to do any kind of parsing in your Java project.
I’ve also provided a runnable Maven project.
Original post
About a year ago I had to implement a query language in a project I was (and currently still am) working on.
We’re creating a specialized search engine where users can use a GUI to query the system.
Power users need to be able to type in search queries and a requirement for this query language is that it would be both simple and powerful.
This led to us ending up with something fairly similar to the where clause in a SQL select statement.
Continue reading →
Interesting links for week 40 2016:
Continue reading →
AngularConnect 2016, held on the September 27th and 28th, was the first Angular conference since the final release of Angular 2.0.
From our company (JDriven) we, 3 front-end loving colleagues, attended this conference and would like to share some of the noteworthy things we’ve learned during the conference.
To allow us some time to write things down as well digest what we have learned, we intend to publish this conference report as a series of 2 or 3 episodes.
In the (first) episode we will go into the topics of performance, support (also for Angular 1.x) , tooling and security.
Future episodes will most likely go into the topics architecture, mobile, data, seo and / or testing.
One of the hottest topics during the AngularConnect 2016 was performance.
Continue reading →
Suppose we have a custom task with some properties that can be configured.
Normally we would add the configuration in the build script.
But we can also use command line options to configure a task.
So when we run the task from the command line we can provide a configuration value for the task on the command line.
To see which command line options are available for a task we can use the Gradle built-in task help followed by the option --task and the task name.
To indicate a property as command line option we use a @Option annotation.
We can specify the name of the command line option, a short description and also the order that is used to display the options with the help task.
Let's create a sample custom task and use the @Option annotation.
In the following build file we create a custom task GenerateVersionFile.
This task generates a file with a default name of version.txt in the build/ directory.
The file contains the project version value. We make the property that defines the output filename as a command line option.
This way the name can be defined when we run Gradle (and still of course using the default configuration in a build file).
Continue reading →
In a previous post we learned that we can check a specific exception is not thrown in our specification with the notThrown method.
If we are not interested in a specific exception, but just want to check no exception at all is thrown, we must use the noExceptionThrown method.
This method return true if the called code doesn't throw an exception.
In the following example we invoke a method (cook) that can throw an exception.
We want to test the case when no exception is thrown:
Continue reading →
Sometimes we want to include the classes from a plugin, like tasks, in our build class path without actually applying the plugin.
Or we want to add the classes to the root project and actually apply the plugin in subprojects.
We can achieve this with a buildScript block and add the plugin dependency to the classpath configuration.
But we can also do this with the newer plugins configuration block.
Inside the plugins block we define the id and the version of the plugin, and since Gradle 3.0 we can also use the apply method.
We have to set the value false to include the plugin to the class path, but not apply it to the project.
In the following example we add the Asciidoctor plugin to our build file, but we only want to use the AsciidoctorTask task from this plugin.
Continue reading →
