Kotlin DSL

plugins {
    application
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

dependencies {
    implementation(project(":tidepool-engine"))
    implementation("info.picocli:picocli:4.7.7")
}

application {
    mainClass = "io.tidepool.cli.Main"
}

plugins {
    id 'application'
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

dependencies {
    implementation project(':tidepool-engine')
    implementation 'info.picocli:picocli:4.7.7'
}

application {
    mainClass = 'io.tidepool.cli.Main'
}

./gradlew :tidepool-cli:build --configuration-cache

Calculating task graph as no cached configuration is available for tasks: :tidepool-cli:build
> Task :tidepool-model:compileJava
> Task :tidepool-model:jar
> Task :tidepool-engine:compileJava
> Task :tidepool-engine:jar
> Task :tidepool-cli:compileJava
> Task :tidepool-cli:jar
> Task :tidepool-cli:startScripts
> Task :tidepool-cli:distTar
> Task :tidepool-cli:distZip
> Task :tidepool-cli:assemble
> Task :tidepool-cli:build
BUILD SUCCESSFUL in 654ms
9 actionable tasks: 9 executed
Configuration cache entry stored.

./gradlew :tidepool-cli:kotlinDslAccessorsReport -q | grep -E 'val .*`(java|application|compileJava|implementation)`'

    val org.gradle.api.Project.`java`: org.gradle.api.plugins.JavaPluginExtension get() =
    val org.gradle.api.Project.`application`: org.gradle.api.plugins.JavaApplication get() =
    val TaskContainer.`compileJava`: TaskProvider<org.gradle.api.tasks.compile.JavaCompile>
    val org.gradle.api.NamedDomainObjectContainer<org.gradle.api.artifacts.Configuration>.`implementation`: NamedDomainObjectProvider<org.gradle.api.artifacts.Configuration>

apply(plugin = "java-library")

repositories {
    mavenCentral()
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

dependencies {
    implementation("org.apache.commons:commons-csv:1.14.1")
}

> Configure project :
e: file://<work>/labs/apply-broken/build.gradle.kts:7:1: Unresolved reference. None of the following candidates is applicable because of a receiver type mismatch:
val PluginDependenciesSpec.java: PluginDependencySpec
e: file://<work>/labs/apply-broken/build.gradle.kts:8:5: Unresolved reference 'toolchain'.
e: file://<work>/labs/apply-broken/build.gradle.kts:9:9: Unresolved reference 'languageVersion'.
e: file://<work>/labs/apply-broken/build.gradle.kts:14:5: Unresolved reference 'implementation'.

FAILURE: Build failed with an exception.
...

apply(plugin = "java-library")

repositories {
    mavenCentral()
}

configure<JavaPluginExtension> {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

dependencies {
    "implementation"("org.apache.commons:commons-csv:1.14.1")
}

./gradlew dependencies --configuration compileClasspath -q --configuration-cache

------------------------------------------------------------
Root project 'lab'
------------------------------------------------------------

compileClasspath - Compile classpath for source set 'main'.
\--- org.apache.commons:commons-csv:1.14.1
     +--- commons-io:commons-io:2.20.0
     \--- commons-codec:commons-codec:1.19.0

A web-based, searchable dependency report is available by adding the --scan option.

plugins {
    `java-library`
}

configurations.create("report")

dependencies {
    report("org.apache.commons:commons-csv:1.14.1")
}

> Configure project :
e: file://<work>/labs/late-config/build.gradle.kts:8:5: Unresolved reference 'report'.

FAILURE: Build failed with an exception.
...
Script compilation error:

  Line 8:     report("org.apache.commons:commons-csv:1.14.1")
              ^ Unresolved reference 'report'.

plugins {
    `java-library`
}

repositories {
    mavenCentral()
}

val report = configurations.create("report")

dependencies {
    report("org.apache.commons:commons-csv:1.14.1")
}

tasks.register("showReport") {
    val name = report.name
    val count = report.dependencies.size
    doLast { println("configuration '$name' declares $count dependency") }
}

configuration 'report' declares 1 dependency

plugins {
    java
}

val copyData by tasks.registering(Copy::class) {
    from("data")
    into(layout.buildDirectory.dir("copied"))
}

val check by tasks.existing {
    dependsOn(copyData)
}

val release by extra("spring-tide")

./gradlew check --warning-mode all

> Configure project :
The 'val name by registering(Type::class) { }' property delegate syntax has been deprecated. This is scheduled to be removed in Gradle 10. Use 'val element = register<Type>(name) { }' instead.
	at Build_gradle.<init>(build.gradle.kts:5)
The 'val name by existing { }' property delegate syntax has been deprecated. This is scheduled to be removed in Gradle 10. Use 'val element = named(name) { }' instead.
	at Build_gradle.<init>(build.gradle.kts:10)
The 'val name by extra(...)' or 'val name by extra { ... }' property delegate syntax has been deprecated. This is scheduled to be removed in Gradle 10. Use 'extra.set(name, value)' instead.
	at Build_gradle.<init>(build.gradle.kts:14)
...
BUILD SUCCESSFUL in 472ms

plugins {
    java
}

"compileJava"() {
    options.encoding = "UTF-8"
}

> Configure project :
e: file://<work>/labs/namecall/build.gradle.kts:5:1: None of the following candidates is applicable:
fun <T : Any> Action<in T>.invoke(target: T): Unit:
...
* What went wrong:
Script compilation errors:

  Line 5: "compileJava"() {
          ^ None of the following candidates is applicable:
...

abstract class StationReport : DefaultTask() {
    @get:Input
    abstract val station: Property<String>

    @get:Input
    abstract val constituents: ListProperty<String>

    @get:InputFiles
    abstract val csv: ConfigurableFileCollection

    @get:OutputFile
    abstract val report: RegularFileProperty

    @TaskAction
    fun write() {
        report.get().asFile.writeText(
            "station=${station.get()}\nconstituents=${constituents.get()}\ncsv=${csv.files.map { it.name }}\n"
        )
    }
}

tasks.register<StationReport>("stationReport") {
    station.set("SF")                                  // classic form
    station = "SF"                                     // lazy assignment, same effect
    constituents = listOf("M2", "S2", "K1")            // ListProperty
    csv.from("data/stations.csv")                      // ConfigurableFileCollection
    csv = files("data/stations.csv")                   // assignment replaces the collection
    report = layout.buildDirectory.file("report.txt")  // RegularFileProperty
    doLast { println(report.get().asFile.readText()) }
}

abstract class StationReport extends DefaultTask {
    @Input
    abstract Property<String> getStation()

    @Input
    abstract ListProperty<String> getConstituents()

    @InputFiles
    abstract ConfigurableFileCollection getCsv()

    @OutputFile
    abstract RegularFileProperty getReport()

    @TaskAction
    void write() {
        report.get().asFile.text =
            "station=${station.get()}\nconstituents=${constituents.get()}\ncsv=${csv.files*.name}\n"
    }
}

tasks.register('stationReport', StationReport) {
    station.set('SF')                                  // classic form
    station = 'SF'                                     // assignment, same effect
    constituents = ['M2', 'S2', 'K1']                  // ListProperty
    csv.from 'data/stations.csv'                       // ConfigurableFileCollection
    csv = files('data/stations.csv')                   // assignment replaces the collection
    report = layout.buildDirectory.file('report.txt')  // RegularFileProperty
    doLast { println report.get().asFile.text }
}

./gradlew stationReport -q --configuration-cache --warning-mode all

station=SF
constituents=[M2, S2, K1]
csv=[stations.csv]

> Configure project :
e: file://<work>/labs/assign-fail/build.gradle.kts:7:5: None of the following candidates is applicable:
fun <T : Any> Property<T>.assign(value: T?): Unit:
  Argument type mismatch: actual type is 'Int', but 'String?' was expected.
fun <T : Any> Property<T>.assign(value: Provider<out T>): Unit:
  Argument type mismatch: actual type is 'Int', but 'Provider<out uninferred T (of fun <T : Any> Property<T>.assign)>' was expected.
e: file://<work>/labs/assign-fail/build.gradle.kts:7:13: No applicable 'assign' function found for '=' overload

plugins {
    java
}

extra["releaseName"] = "spring-tide"                              // create
val releaseName = extra["releaseName"] as String                   // read and cast
val maybe = if (extra.has("notDefined")) extra["notDefined"] else null   // absent property

tasks.test {
    extra["reportType"] = "dev"                                   // extra property on a task
}

tasks.register("showExtra") {
    // copy script-level values into locals: reading them in doLast would capture the script object
    val release = releaseName
    val missing = maybe
    val type = tasks.test.map { it.extra["reportType"] as String }
    doLast { println("release=$release maybe=$missing reportType=${type.get()}") }
}

plugins {
    id 'java'
}

ext.releaseName = 'spring-tide'                                    // create
def releaseName = ext.releaseName                                   // read
def maybe = ext.has('notDefined') ? ext.notDefined : null           // absent property

tasks.named('test') {
    ext.reportType = 'dev'                                         // extra property on a task
}

def reportType = tasks.named('test').map { it.ext.reportType }

tasks.register('showExtra') {
    doLast { println "release=$releaseName maybe=$maybe reportType=${reportType.get()}" }
}

./gradlew showExtra -q --configuration-cache

release=spring-tide maybe=null reportType=dev

val releaseName = "spring-tide"

tasks.register("showRelease") {
    doLast { println("release=$releaseName") }
}

> Task :showRelease
release=spring-tide
...
* What went wrong:
Configuration cache problems found in this build.

1 problem was found storing the configuration cache.
- Task `:showRelease` of type `org.gradle.api.DefaultTask`: cannot serialize Gradle script object references as these are not supported with the configuration cache.
  See https://docs.gradle.org/9.8.1/userguide/configuration_cache_requirements.html#config_cache:requirements:disallowed_types
...
Configuration cache entry discarded with 1 problem.

package io.tidepool

import org.gradle.api.Plugin
import org.gradle.api.Project

class LegacyPlugin implements Plugin<Project> {
    void apply(Project project) {
        project.extensions.create('legacy', LegacyExtension)
    }
}

class PackageSpec {
    String name
    String version
}

// A plugin written in Groovy: its methods take a Closure, not an Action
class LegacyExtension {
    final PackageSpec spec = new PackageSpec()

    // calls the closure with the spec as its argument
    void pkg(Closure c) { c.call(spec) }

    // sets the spec as the closure's delegate
    void pkgDelegate(Closure c) {
        c.delegate = spec
        c.resolveStrategy = Closure.DELEGATE_FIRST
        c.call()
    }

    String describe() { "${spec.name}:${spec.version}" }
}

import io.tidepool.PackageSpec

plugins {
    id("tidepool.java-conventions")
    id("tidepool.legacy")
}

legacy {
    pkg(closureOf<PackageSpec> {
        name = "tidepool-app"
        version = "1.0.0"
    })
}

tasks.register("describeLegacy") {
    val text = legacy.describe()
    doLast { println("legacy extension: $text") }
}

./gradlew :app:describeLegacy -q --configuration-cache

legacy extension: tidepool-app:1.0.0

tasks.register("antEcho") {
    val outDir = layout.buildDirectory.dir("ant-out").get().asFile
    doLast {
        // the Ant builder is a Groovy object: names become method calls
        ant.withGroovyBuilder {
            "echo"("message" to "hello from AntBuilder")
            "mkdir"("dir" to outDir)
        }
    }
}

// a Groovy script can hold the dynamic parts
apply(from = "legacy.gradle")

def message = 'configured by legacy.gradle'

tasks.register('groovyHello') {
    doLast { println "Hello from Groovy: ${message}" }
}

./gradlew antEcho groovyHello --configuration-cache

Calculating task graph as no cached configuration is available for tasks: antEcho groovyHello
> Task :groovyHello
Hello from Groovy: configured by legacy.gradle
> Task :antEcho
[ant:echo] hello from AntBuilder
BUILD SUCCESSFUL in 415ms
2 actionable tasks: 2 executed
Configuration cache entry stored.