As I’ve recently posted on LinkedIn I’ve been a part of JDriven for seven years. This is as close to its conception as I could get. In this post I’ll try to explain what it means for me to be a part of this awesome company. Continue reading
The Node class in Groovy has the methods depthFirst and breadthFirst to return a collection of Node objects using either depth or breadth first traversal. Since Groovy 2.5.0 we can specify if we want to use preorder (the default) or postorder traversal. Also the methods now accept a Closure that will be invoked for each visited node. The Closure has the current Node as first argument, the second argument is the tree level of the current node.
A tuple is an ordered, immutable list of elements. Groovy supported tuples with one or two elements before Groovy 2.5.0. Since Groovy 2.5.0 we can use tuples with maximal nine items. Groovy added the classes Tuple3 up to Tuple9. The bonus we get compared to an unmodifiable list with elements is that we can use properties like first, second, third, fourth, fifth, sixth, seventh, eighth, ninth to get items at the specified position.
In the following example we use different Tuple classes:
|
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 37 38 39 40 41 42 |
// We can define the types of the elements when we // construct a tuple. def tuple3 = new Tuple3<String, Integer, BigDecimal>('add', 2, 40.0) // We can use first, second, third properties // to get values from the tuple. assert tuple3.first == 'add' assert tuple3.second == 2 assert tuple3.third == 40.0 // We can use the [index] syntax to get element. assert tuple3[0] == 'add' // Fully typed tuple. Tuple4<String, Integer, BigDecimal, Integer> tuple4 = new Tuple4<>('subtract', 100, 55.0, 3) assert tuple4.first == 'subtract' assert tuple4.second == 100 assert tuple4.third == 55.0 assert tuple4.fourth == 3 assert tuple4[-1] == 3 // With subTuple we can get subsequent // values from the tuple as a new tuple. assert tuple4.subTuple(2, tuple4.size()) == new Tuple2<BigDecimal, Integer>(55.0, 3) // We can imagine how to work with Tuple4..Tuple8 :-) // ... // Finally a tuple with 9 items. def tuple9 = new Tuple9('Groovy', 'rocks', 'and', 'is', 'fun', 'to', 'use', 'as', 'language') assert tuple9.fifth == 'fun' assert tuple9.sixth == 'to' assert tuple9.seventh == 'use' assert tuple9.eighth == 'as' assert tuple9.ninth == 'language' // Tuple extends AbstractList, so we can // use all methods from List as well. assert tuple9.join(' ') == 'Groovy rocks and is fun to use as language' |
Written with Groovy 2.5.0.
Groovy supports named arguments for methods. Actually Groovy collects all named arguments (defined using the name followed by a : and the value) into a Map. The Map must be the first parameter of the method to make it all work. Since Groovy 2.5.0 we can use the @NamedVariant AST transformation annotation to let Groovy create a method where the first parameter is a Map to support named arguments for an existing method. The existing method is still available, but Groovy adds an extra method to our generated class.
By default Groovy will make the first parameters of the original method part of the new method supporting named arguments. If the first parameters is a class type, then the properties of the class can be used as named arguments. We can also explicitly define which parameters of our original method should be named arguments using the annotations @NamedParam and @NamedDelegate. These annotations need to defined for each parameter. The newly created method by the AST transformation invokes the original method.
When we wanted to create collections in Groovy that were unmodifiable we could use asImmutable. Since Groovy 2.5.0 we can also use the asUnmodifiable method on collections. The method can be applied on all Collection types including Map.
In the following example we use asUnmodifiable on a List and Map:
|
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 |
import static groovy.test.GroovyAssert.shouldFail // Create List that is unmodifiable. def list = ['Groovy', 'Gradle', 'Asciidoctor', 'Micronaut'].asUnmodifiable() shouldFail(UnsupportedOperationException) { // We cannot add new items. list << 'Java' } shouldFail(UnsupportedOperationException) { // We cannot change items. list[0] = 'Java' } // Create Map that is unmodifiable. def data = [name: 'Messages from mrhaki', subject: 'Gr8 stuff'].asUnmodifiable() shouldFail(UnsupportedOperationException) { // We cannot add a new key. data.subject = 'Dev subjects' } shouldFail(UnsupportedOperationException) { // We cannot change the value of a key. data.blog = true } |
Written with Groovy 2.5.0.
Since the early days of Groovy we can create POGO (Plain Old Groovy Objects) classes that will have a constructor with a Map argument. Groovy adds the constructor automatically in the generated class. We can use named arguments to create an instance of a POGO, because of the Map argument constructor. This only works if we don’t add our own constructor and the properties are not final. Since Groovy 2.5.0 we can use the @MapConstrutor AST transformation annotation to add a constructor with a Map argument. Using the annotation we can have more options to customize the generated constructor. We can for example let Groovy generate the constructor with Map argument and add our own constructor. Also properties can be final and we can still use a constructor with Map argument.
A lot of new AST transformation annotations are added in Groovy 2.5.0. One of them is the @AutoImplement annotation. If we apply this annotation to our class dummy implementations for abstract methods in superclasses or methods in implemented interfaces are created. This can be useful to have something in place and then gradually write real implementations for the abstract or interface methods. The transformation will not alter any method that is already implemented by custom code.
When we apply the @AutoImplement annotation the default implementation for an abstract method from a superclass or method from a interface is simple. If the method has a return type the default value of that return type is returned. For example false for a boolean and null for an object type. But the @AutoImplement annotation has some attributes we can use to change the default implementation. We can set the exception attribute and assign a exception type. The implementation of the methods is than to throw that exception when the method is invoked. With the optional message attribute we can set the exception message. Finally we can use the code attribute to define a Closure with statements that will be called as the implementation of abstract and interface methods.
Groovy 2.5.0 adds the possibility to customize JSON output via a JsonGenerator instance. The easiest way to turn an object into a JSON string value is via JsonOutput.toJson. This method uses a default JsonGenerator with sensible defaults for JSON output. But we can customize this generator and create JSON output using the custom generator. To create a custom generator we use a builder accessible via JsonGenerator.Options. Via a fluent API we can for example ignore fields with null values in the output, change the date format for dates and ignore fields by their name or type of the value. And we can add a custom converter for types via either an implementation of the conversion as Closure or implementation of the JsonGenerator.Converter interface. To get the JSON string we simple invoke the toJson method of our generator.
Versions of Groovy before 2.5.0 implemented pop and push methods for the List class for items at the end of a List object. The pop method removed the last item of a List and push added a item to the List. Groovy 2.5.0 reimplemented the methods so they now work on the first item of a List instance. To remove an item from the end of the list we can use the newly added method removeLast.
In the following example Groovy code we use the removeLast and add methods to remove and add items to the end of the list. And with the pop and push methods we remove and add items to the beginnen of the list:
|
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 |
def list = ['Groovy', 'is', 'great!'] // Remove last item from list // with removeLast(). assert list.removeLast() == 'great!' assert list == ['Groovy', 'is'] // Remove last item which is now 'is'. list.removeLast() // Add new item to end of the list. list.add 'rocks!' assert list.join(' ') == 'Groovy rocks!' /* IMPORTANT */ /* pop() and push() implementations has changed */ /* in Groovy 2.5.0. They now work on the first */ /* item in a List instead of the last. */ // Using pop() we remove the first item // of a List. assert list.pop() == 'Groovy' // And with push we add item to // beginning of a List. list.push 'Spock' assert list.join(' ') == 'Spock rocks!' |
Written with Groovy 2.5.0.
For a long time we could get the tail or init values for a collection. Groovy 2.5.0 adds the methods inits and tails for Iterable objects. These methods return a List with List values where the first element is the original collection and the next is the result of init or tail on the previous element. This is repeated until the result of init or tail is an empty List.
In the next example script we have a original collection of letters. We first run the init and tail methods (without the s). Next we look at the result of invoking inits and tails:
|
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 |
def letters = ('a'..'d').toList() assert letters == ['a', 'b', 'c', 'd'] assert letters.init() == ['a', 'b', 'c'] assert letters.tail() == ['b', 'c', 'd'] // Inits returns collection of all init() // results for an Iterable. The first element // has the original values, the next element // the result of init() // of the previous element and so on until // an empty List is the result. assert letters.inits() == [ ['a', 'b', 'c', 'd'], ['a', 'b', 'c'], ['a', 'b'], ['a'], []] // Tails returns collection of all tail() // results for an Iterable. The first element // has the original values, the next element // the result of tail() // of the previous element and so on until // an empty List is the result. assert letters.tails() == [ ['a', 'b', 'c', 'd'], ['b', 'c', 'd'], ['c', 'd'], ['d'], []] |
Written with Groovy 2.5.0.