Equivalent closures in Groovy and Kotlin

Closures in Groovy and Kotlin are very similar, but have different names. Here is is list with few of them.

Project with samples is here:
https://github.com/bugs84/samples/tree/master/kotlin-groovy-closures

Groovy	Kotlin
each	forEach
collect	map
findAll	filter
find	find
groupBy	groupBy
eachWithIndex	forEachIndexed
with	run, let
with :-/	apply, also

Note: Not every think is absolutely same, but it’s at least quite similar.

each vs. forEach

def sum = 0
[1, 2, 3].each { sum += it }
assert sum == 6

var sum = 0  
listOf(1, 2, 3).forEach { sum += it }  
assertThat(sum).isEqualTo(6)

collect vs. map

List<String> result = [1, 2, 3].collect { "S-" + it }  
assert result == ["S-1", "S-2", "S-3"]

val result = listOf(1, 2, 3).map { "S-" + it }  
assertThat(result).isEqualTo(listOf("S-1", "S-2", "S-3"))

findAll vs. filter

assert [1, 2, 3, 4, 5].findAll { it < 3 } == [1, 2]

assertThat(
        listOf(1, 2, 3, 4, 5).filter { it < 3 }
).isEqualTo(
        listOf(1, 2)
)

find vs. find

assert [1, 2, 3, 4, 5].find { it < 3 } == 1

assertThat(  
        listOf(1, 2, 3, 4, 5).find { it < 3 }  
).isEqualTo(
        1
)

groupBy vs. groupBy

Map<Integer, List<Integer>> groupBy = [1, 2, 3, 4, 5, 6, 7].groupBy { it % 3 }  
assert groupBy == [  
        0: [3, 6],  
        1: [1, 4, 7],  
        2: [2, 5]  
]

val groupBy: Map<Int, List<Int>> = listOf(1, 2, 3, 4, 5, 6, 7).groupBy { it % 3 }  
assertThat(groupBy).isEqualTo(
    mapOf(  
        0 to listOf(3, 6),  
        1 to listOf(1, 4, 7),  
        2 to listOf(2, 5)  
    ))

eachWithIndex vs. forEachIndexed

def result = ""  
["A", "B"].eachWithIndex { entry, index ->  
    result += "$index:$entry, "  
}  
assert result == "0:A, 1:B, "

var result = ""  
listOf("A", "B").forEachIndexed { index, entry ->  
  result += "$index:$entry, "  
}  
assertThat(result).isEqualTo("0:A, 1:B, ")

Note: entry and index are in different order

with vs. run

assert "string".with {  
    length()  
} == 6

assertThat(  
    "string".run {  
        length  
    }  
).isEqualTo(6)

with/run can be used just for for creating an scope:

assert with {  
    "AAA"  
} == "AAA"

assertThat(  
        run {  
            "AAA"  
        }  
).isEqualTo("AAA")

In Groovy with works as Kotlin let as well. See next example:

with vs. let

assert "string".with {  
    it.length()  
} == 6

assertThat(  
        "string".let {  
            it.length  
        }  
).isEqualTo(6)

with vs. apply

assert "string".with {  
    println length()  
    it //  :-/  
} == "string"

assertThat(  
        "string".apply {  
            println(length)  
        }
).isEqualTo("string")

with vs. also

assert "string".with {  
    println it.length()  
    it //  :-/  
} == "string"

assertThat(  
        "string".also {  
            println(it.length)  
        }  
).isEqualTo("string")

Kotlin - Append to StringBuilder using “+” “plus” instead of append() method

In Kotlin you can easily override operator. I will show simple example how can this help you to write more readable code.

At first we will override “plus” operator on for StringBuilder class

operator fun StringBuilder.plus(str: String): StringBuilder {
    append(str)
    return this
}

If you define this function as private. It will be accessible only in file, where it is defined. Or public and then it can be used anywhere in project.

And from this code:

sb.append("function ").append(generatedClassName).append("() {").append("\n")
functions.forEach { function: Function ->
    sb.append(indent).append("this.").append(function.name).append(" = undefined;").append("\n")
}
sb.append("}").append("\n")
sb.append("var ").append(name).append(" = new ").append(generatedClassName).append("();").append("\n")

we can remove all ‘append’ words and we get this code:
=>

sb + "function " + generatedClassName + "() {" + "\n"
functions.forEach { function: Function ->
    sb + indent + "this." + function.name + " = undefined;" + "\n"
}
sb + "}" + "\n"
sb + "var " + name + " = new " + generatedClassName + "();" + "\n"

Very simple, code is shorter and more readable.

Gradle Kotlin DSL - Tipy

IntelliJ IDEA build by Gradle

build projektu u nás nedělá přímo IntelliJ IDEA ale deleguje to na Gradle

Idea Settings-> Gradle -> Runner -> Checkbox ‘Delegate IDE build/run actions to gradle’

Poznámky:

• při buildu idea spouští tyhle tasky z gradlu :classes :testClasses

Jak Debugovat

1. gradlew.bat <task> --no-daemon -Dorg.gradle.debug=true
2. pak se připojit remote debuggerem na port 5005
   • Příklad nastavení v IntelliJ IDEA:
     

ALE pozor! - build nejde spustit, pokud už předtím daemon běží

• v tom potřeba je potřeba ho vypnout gradlew.bat --stop (to zastaví daemony)

Kam jde dát breakpoint:

• jde do buildSrc
• nešlo mi dát přímo do tasku v build.gradle.kts
• nešlo mi dát do metody v build.gradle.kts (to v groovy gradlu fungovalo)

Parallelní build

používáme parallelní build java org.gradle.parallel=true
Proto pozor tasky, které na sobě nejsou závislé se spustí parallelně to znamená:
gradlew test uploadTestResults zde je nutné mít nastavenou závislost mezi tasky např:

tasks {
    val test by tasks.getting  
      
    val uploadTestResults by tasks.creating {  
        dependsOn(test)
        doLast {  
            ... process test resutls ...
        }  
    }
}

exclude task

V případě, vyjímečně chci spustit task bez jeho závislostí (např. když ho píšu) lze

gradlew uploadTestResults -x test - spustí ‘uploadTestResults’ bez tasku ‘test’

V konfiguraci tasku jde upravit jakékoliv parametry např:

gradle.startParameter.excludedTaskNames += "myTaskToExclude"

Logování v build scriptu

V build.gradle.kts je k dispzici variabla logger.
Gradle přidává novou logovací uroveň lifecycle a quiet
error, quiet, warning, lifecycle, info, debug
Výchozí úroven logovaní NENI info, ale LIFECYCLE !!!

gradlew <myTask> --info   - spusti příkaz s urovní info

Detaily zde: Gradle Logging

Jak získat logger uvnit buildSrc

val logger = Logging.getLogger(this.javaClass)

kde Logging je: import org.gradle.api.logging.Logging

Pak lze už normálně logovat:

logger.lifecycle("My log message")

Nastavení tasku

Vše patří do build.gradle.kts sekce tasks { ... }

Získání existujícího tasku:

val test by tasks.getting

Vytvoření nového tasku:

val jasmineResultsParser by tasks.creating {  
    doLast {  
      ... what task should do ...
    }  
}

validator, který zjistí zda je task “up to date”:

mytask {
    outputs.upToDateWhen { myFile.exists() }
}

Spouštět task jen v případě, že se spustí jiný task (=není excludovaný)

onlyIf{ 
   gradle.taskGraph.hasTask("mySubModule:test")
}

Další

Dependencies

• gradlew :nuc-common:dependencies --configuration testCompile
  • vypíše strom závislostí pouze pro podprojekt ‘nuc-common’ a pouze pro konfiguraci ‘testCompile’

zjistit co se spusti

gradlew <myTask> --dry-run - nespustí příkazy, jen ukáže co by se spustilo

v IntelliJ IDEA nefunguje moc dobře navigace mezi fily

může pomoct plugin ‘Gradle/Maven Navigation’

Dependency management

Zavislosti se vyhodnocují jinak než v Mavenu. Gradle použije vždy nejnovější.

dependencyManagement {
    overriddenByDependencies(false)
}