Gradle

https://docs.gradle.org/current
Admin
Gradle is an open-source build automation tool that uses a Groovy-based DSL for configuring and...
Tokens:7,864,888
Snippets:78,183
Trust Score:10
Update:2 days ago
Show doc for...
Tokens:
Raw
### Example project path

Source: https://docs.gradle.org/current/userguide/multi_project_builds_intermediate.html

Shows the pattern of a project path, starting with a colon for the root project.

```text
:sub-project-1
```

--------------------------------

### Verbose VFS logging output example

Source: https://docs.gradle.org/current/userguide/file_system_watching.html

This example shows the command to run a build with verbose VFS logging and the output produced at the start and end of the build, including the number of file system events and the state of the virtual file system.

```bash
$ ./gradlew assemble --watch-fs -Dorg.gradle.vfs.verbose=true
```

```text
Received 3 file system events since last build while watching 1 locations
Virtual file system retained information about 2 files, 2 directories and 0 missing files since last build
> Task :compileJava NO-SOURCE
> Task :processResources NO-SOURCE
> Task :classes UP-TO-DATE
> Task :jar UP-TO-DATE
> Task :assemble UP-TO-DATE

BUILD SUCCESSFUL in 58ms
1 actionable task: 1 up-to-date
Received 5 file system events during the current build while watching 1 locations
Virtual file system retains information about 3 files, 2 directories and 2 missing files until next build
```

--------------------------------

### Run gradle to test installation

Source: https://docs.gradle.org/current/userguide/part1_gradle_init.html

Run 'gradle' from the command line to verify the installation. If Gradle is not installed, refer to the installation section.

```bash
$ gradle
```

--------------------------------

### Create and enter the plugin-tutorial directory

Source: https://docs.gradle.org/current/userguide/part1_gradle_init_plugin.html

Creates a new directory named `plugin-tutorial` and navigates into it. This is the first step before running `gradle init`.

```bash
$ mkdir plugin-tutorial
$ cd plugin-tutorial
```

--------------------------------

### Example: Customizing Start Script Templates

Source: https://docs.gradle.org/current/javadoc/org/gradle/jvm/application/tasks/CreateStartScripts.html

Example showing how to customize the start script templates using the CreateStartScripts task.

```APIDOC
## Example: Customizing Start Script Templates

### Description
This example demonstrates how to customize the start script templates for the CreateStartScripts task.

### Code
```groovy
task createStartScripts(type: CreateStartScripts) {
  unixStartScriptGenerator.template = resources.text.fromFile('customUnixStartScript.txt')
  windowsStartScriptGenerator.template = resources.text.fromFile('customWindowsStartScript.txt')
}
```

```

--------------------------------

### Create tutorial directory

Source: https://docs.gradle.org/current/userguide/part1_gradle_init.html

Creates a new directory named 'tutorial'.

```bash
$ mkdir tutorial
```

--------------------------------

### Refer to configuration by name to get dependencies

Source: https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.ConfigurationContainer.html

Example showing how to refer to a given configuration by name to get hold of all dependencies (e.g., jars) and copy them to a folder.

```groovy
  plugins {
      id 'java' //so that I can use 'implementation', 'compileClasspath' configuration
  }

  dependencies {
      implementation 'org.slf4j:slf4j-api:2.0.17'
  }

  //copying all dependencies attached to 'compileClasspath' into a specific folder
  task copyAllDependencies(type: Copy) {
    //referring to the 'compileClasspath' configuration
    from configurations.compileClasspath
    into 'allLibs'
  }
```

--------------------------------

### get(handler)

Source: https://docs.gradle.org/current/kotlin-dsl/gradle/org.gradle.tooling/-model-builder/index.html

Starts fetching the model, passing the result to the given handler when complete.

```APIDOC
## get(handler)

### Description
Starts fetching the model, passing the result to the given handler when complete.

### Method
get

### Signature
`abstract fun get(handler: ResultHandler<in T>)`

### Parameters
- **handler** (ResultHandler<in T>) - Required - The handler to receive the result.
```

--------------------------------

### Run hello task and output (first example)

Source: https://docs.gradle.org/current/userguide/implementing_gradle_plugins_binary.html

Command to run the hello task and its expected output for the first example.

```bash
$ ./gradlew -q hello
```

```text
Hi from Gradle
```

--------------------------------

### Create a new directory for the tutorial

Source: https://docs.gradle.org/current/userguide/part1_gradle_init_project.html

Creates a new directory named `authoring-tutorial` for the project.

```bash
$ mkdir authoring-tutorial
```

--------------------------------

### my-app/app/build.gradle - applying included plugin

Source: https://docs.gradle.org/current/userguide/composite_builds.html

Groovy DSL build script that applies the 'com.example.hello' plugin from the included build.

```groovy
plugins {
    id 'application'
    id('com.example.hello') // from the Included Build in pluginManagement
}
```

--------------------------------

### get(ResultHandler)

Source: https://docs.gradle.org/current/javadoc/index-all.html

Method in interface org.gradle.tooling.ModelBuilder. Starts fetching the model, passing the result to the given handler when complete.

```APIDOC
## get(ResultHandler)

### Description
Starts fetching the model, passing the result to the given handler when complete.

### Method
GET

### Endpoint
org.gradle.tooling.ModelBuilder#get(ResultHandler)

### Parameters
#### Path Parameters
- **ResultHandler** (ResultHandler) - Required - The handler to receive the result.

### Response
#### Success Response (200)
- **result** (Object) - The model fetched.

```

--------------------------------

### get(ResultHandler<? super T>)

Source: https://docs.gradle.org/current/javadoc/org/gradle/tooling/ModelBuilder.html

Starts fetching the model, passing the result to the given handler when complete. This method is asynchronous.

```APIDOC
## get(ResultHandler<? super T>)

### Description
Starts fetching the model, passing the result to the given handler when complete.

### Method
get

### Signature
`void get(ResultHandler<? super T> handler)`

### Parameters
- **handler** (ResultHandler<? super T>) - Required - The handler to receive the result.

### Returns
- **void** - This method does not return a value.

### Since
1.0
```

--------------------------------

### Groovy DSL: hello-a/build.gradle

Source: https://docs.gradle.org/current/userguide/plugins_intermediate.html

Applies the 'com.example.hello' plugin in the hello-a subproject.

```groovy
plugins {
    id 'com.example.hello'
}
```

--------------------------------

### Example settings.gradle.kts file

Source: https://docs.gradle.org/current/userguide/part4_settings_file.html

A complete Kotlin settings file example with plugin declaration, root project name, and project includes.

```kotlin
plugins {                                                                   (1)
    id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"  (2)
}

rootProject.name = "authoring-tutorial"                                     (3)

include("app")                                                              (4)
include("lib")

includeBuild("gradle/license-plugin")                                       (5)
```

--------------------------------

### Custom Script Generators

Source: https://docs.gradle.org/current/dsl/org.gradle.jvm.application.tasks.CreateStartScripts.html

Example of customizing the Unix and Windows start script generators by implementing the ScriptGenerator interface.

```APIDOC
## Custom Script Generators

### Description
Shows how to replace the default start script generators with custom implementations.

### Example
```groovy
task createStartScripts(type: CreateStartScripts) {
  unixStartScriptGenerator = new CustomUnixStartScriptGenerator()
  windowsStartScriptGenerator = new CustomWindowsStartScriptGenerator()
}

class CustomUnixStartScriptGenerator implements ScriptGenerator {
  void generateScript(JavaAppStartScriptGenerationDetails details, Writer destination) {
    // implementation
  }
}

class CustomWindowsStartScriptGenerator implements ScriptGenerator {
  void generateScript(JavaAppStartScriptGenerationDetails details, Writer destination) {
    // implementation
  }
}
```

### Properties
- **unixStartScriptGenerator** (ScriptGenerator) - The generator for UNIX-like environments.
- **windowsStartScriptGenerator** (ScriptGenerator) - The generator for Windows environments.

### Notes
- The default generators are of type TemplateBasedScriptGenerator with default templates.
- Templates can be changed via the TemplateBasedScriptGenerator.setTemplate(TextResource) method.
```

--------------------------------

### Groovy property syntax examples

Source: https://docs.gradle.org/current/userguide/groovy_build_script_primer.html

Shows the general syntax for getting and setting properties, and embedding property values in strings.

```groovy
<obj>.<name>                // Get a property value
<obj>.<name> = <value>      // Set a property to a new value
"$<name>"                   // Embed a property value in a string
"${<obj>.<name>}"           // Same as previous (embedded value)
```

--------------------------------

### Kotlin DSL: hello-a/build.gradle.kts

Source: https://docs.gradle.org/current/userguide/plugins_intermediate.html

Applies the 'com.example.hello' plugin in the hello-a subproject.

```kotlin
plugins {
    id("com.example.hello")
}
```

--------------------------------

### CreateStartScripts Task Configuration

Source: https://docs.gradle.org/current/dsl/org.gradle.jvm.application.tasks.CreateStartScripts.html

Example configuration for the CreateStartScripts task, showing how to customize the Unix and Windows start script templates.

```APIDOC
## CreateStartScripts Task

### Description
Generates start scripts for a Java application. The task has properties that can be configured to customize the generated scripts.

### Properties
- `applicationName` - See [`JavaAppStartScriptGenerationDetails.getApplicationName()`](https://docs.gradle.org/current/javadoc/org/gradle/jvm/application/scripts/JavaAppStartScriptGenerationDetails.html#getApplicationName--).
- `gitRef` - See [`JavaAppStartScriptGenerationDetails.getGitRef()`](https://docs.gradle.org/current/javadoc/org/gradle/jvm/application/scripts/JavaAppStartScriptGenerationDetails.html#getGitRef--).
- `optsEnvironmentVar` - See [`JavaAppStartScriptGenerationDetails.getOptsEnvironmentVar()`](https://docs.gradle.org/current/javadoc/org/gradle/jvm/application/scripts/JavaAppStartScriptGenerationDetails.html#getOptsEnvironmentVar--).
- `exitEnvironmentVar` - See [`JavaAppStartScriptGenerationDetails.getExitEnvironmentVar()`](https://docs.gradle.org/current/javadoc/org/gradle/jvm/application/scripts/JavaAppStartScriptGenerationDetails.html#getExitEnvironmentVar--).
- `moduleEntryPoint` - The module entry point, or `null` if none. Will also include the main class name if present, in the form `[moduleName]/[className]`.
- `mainClassName` - The main class name, or usually `""` if none. For legacy reasons, this may be set to `--module [moduleEntryPoint]` when using a main module. This behavior should not be relied upon and may be removed in a future release.
- `entryPointArgs` - The arguments to be used on the command-line to enter the application, as a joined string. It should be inserted before the program arguments.
- `defaultJvmOpts` - See [`JavaAppStartScriptGenerationDetails.getDefaultJvmOpts()`](https://docs.gradle.org/current/javadoc/org/gradle/jvm/application/scripts/JavaAppStartScriptGenerationDetails.html#getDefaultJvmOpts--).
- `appNameSystemProperty` - See [`JavaAppStartScriptGenerationDetails.getAppNameSystemProperty()`](https://docs.gradle.org/current/javadoc/org/gradle/jvm/application/scripts/JavaAppStartScriptGenerationDetails.html#getAppNameSystemProperty--).
- `appHomeRelativePath` - The path, relative to the script's own path, of the app home.
- `classpath` - See [`JavaAppStartScriptGenerationDetails.getClasspath()`](https://docs.gradle.org/current/javadoc/org/gradle/jvm/application/scripts/JavaAppStartScriptGenerationDetails.html#getClasspath--). It is already encoded as a joined string.
- `modulePath` (different capitalization) - See [`JavaAppStartScriptGenerationDetails.getModulePath()`](https://docs.gradle.org/current/javadoc/org/gradle/jvm/application/scripts/JavaAppStartScriptGenerationDetails.html#getModulePath--). It is already encoded as a joined string.

### Usage Example
```groovy
task createStartScripts(type: CreateStartScripts) {
  unixStartScriptGenerator.template = resources.text.fromFile('customUnixStartScript.txt')
  windowsStartScriptGenerator.template = resources.text.fromFile('customWindowsStartScript.txt')
}
```

### Notes
The encoded paths expect a variable named `APP_HOME` to be present in the script, set to the application home directory which can be resolved using `appHomeRelativePath`.
```

--------------------------------

### Example settings.gradle file

Source: https://docs.gradle.org/current/userguide/part4_settings_file.html

A complete Groovy settings file example with plugin declaration, root project name, and project includes.

```groovy
plugins {                                                                   (1)
    id 'org.gradle.toolchains.foojay-resolver-convention' version '1.0.0'   (2)
}

rootProject.name = 'running-tutorial-groovy'                                (3)

include('app')                                                              (4)
include('lib')

includeBuild('gradle/license-plugin')                                       (5)
```

--------------------------------

### build.gradle.kts - Configuration and Execution Phase Example

Source: https://docs.gradle.org/current/userguide/build_lifecycle_intermediate.html

This build file demonstrates the configuration and execution phases. It registers tasks 'configured', 'test', and 'testBoth', with print statements showing when each part runs. The 'configured' task is not executed because it is not requested.

```kotlin
// Configuration Phase
println("This is executed during the configuration phase.")

tasks.register("configured") {
    println("This is also executed during the configuration phase.")
}

// Execution Phase
tasks.register("test") {
    doLast {
        println("This is executed during the execution phase.")
    }
}

// Configurations AND Execution Phase
tasks.register("testBoth") {
    println("This is executed during the configuration phase as well.")
    doFirst {
        println("This is executed first during the execution phase.")
    }
    doLast {
        println("This is executed last during the execution phase.")
    }
}
```

--------------------------------

### Project structure for convention plugin example

Source: https://docs.gradle.org/current/userguide/plugins.html

Shows the directory layout of the example build with buildSrc, data-model, database-logic, and app subprojects.

```text
.
├── buildSrc
│   ├── src
│   │   └──...
│   └── build.gradle.kts
├── data-model
│   ├── src
│   │   └──...
│   └── build.gradle.kts
├── database-logic
│   ├── src
│   │   └──...
│   └── build.gradle.kts
├── app
│   ├── src
│   │   └──...
│   └── build.gradle.kts
└── settings.gradle.kts
```

--------------------------------

### Groovy: Find all environment variables starting with JDK_

Source: https://docs.gradle.org/current/userguide/configuration_cache_requirements.html

This example uses System.getenv().findAll with a predicate to find environment variables whose names start with "JDK_". The predicate is opaque to the Configuration Cache, so all environment variables are considered inputs.

```groovy
def jdkLocations = System.getenv().findAll {
    key, _ -> key.startsWith("JDK_")
}
```

--------------------------------

### Full build script example (Kotlin DSL)

Source: https://docs.gradle.org/current/userguide/writing_build_scripts_intermediate.html

Complete build.gradle.kts example showing plugins, repositories, dependencies, application configuration, and task configuration. Includes numbered comments (1)-(5) that correspond to the breakdown sections.

```kotlin
plugins {   (1)
    id("application")
}

repositories {  (2)
    mavenCentral()
}

dependencies {  (3)
    testImplementation("org.junit.jupiter:junit-jupiter-engine:5.9.3")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
    implementation("com.google.guava:guava:32.1.1-jre")
}

application {   (4)
    mainClass = "com.example.Main"
}

tasks.named<Test>("test") { (5)
    useJUnitPlatform()
}

tasks.named<Javadoc>("javadoc").configure {
    exclude("app/Internal*.java")
    exclude("app/internal/*")
}

tasks.register<Zip>("zip-reports") {
    from("Reports/")
    include("*")
    archiveFileName.set("Reports.zip")
    destinationDirectory.set(file("/dir"))
}
```

--------------------------------

### defaultJvmOpts

Source: https://docs.gradle.org/current/kotlin-dsl/gradle/org.gradle.jvm.application.tasks/-create-start-scripts/default-jvm-opts.html

Sets or gets the default JVM options for the start scripts. This property is annotated with @Input and @Optional, meaning it is an optional input for the task.

```APIDOC
## defaultJvmOpts

### Description
Sets or gets the default JVM options for the start scripts. This property is annotated with @Input and @Optional, meaning it is an optional input for the task.

### Property
`open var defaultJvmOpts: Iterable<String>?`

### Annotations
- `@get:Nullable`
- `@get:Optional`
- `@get:Input`

### Type
`Iterable<String>?`

### Source
[CreateStartScripts.java#L138](https://github.com/gradle/gradle/blob/a0790e50a460a013e197db8670e24d7a4ba95f42/platforms/jvm/plugins-application/src/main/java//org/gradle/jvm/application/tasks/CreateStartScripts.java#L138)
```

--------------------------------

### WorkItemOperationResult

Source: https://docs.gradle.org/current/javadoc/org/gradle/tooling/events/work/WorkItemOperationResult.html

Describes the result of running a work item operation. This interface extends OperationResult and inherits methods to get the start and end times of the operation.

```APIDOC
## Interface WorkItemOperationResult

### Description
Describes the result of running a work item operation.

### Since
5.1

### All Superinterfaces
- `OperationResult`

### All Known Subinterfaces
- `WorkItemFailureResult`
- `WorkItemSuccessResult`

### Inherited Methods
#### From OperationResult
- `getEndTime()` - Returns the end time of the operation.
- `getStartTime()` - Returns the start time of the operation.

```

--------------------------------

### build.gradle - Configuration and Execution Phase Example (Groovy)

Source: https://docs.gradle.org/current/userguide/build_lifecycle_intermediate.html

This build file demonstrates the configuration and execution phases in Groovy DSL. It registers tasks 'configured', 'test', and 'testBoth', with print statements showing when each part runs.

```groovy
// Configuration Phase
println 'This is executed during the configuration phase.'

tasks.register('configured') {
    println 'This is also executed during the configuration phase.'
}

// Execution Phase
tasks.register('test') {
    doLast {
        println 'This is executed during the execution phase.'
    }
}

// Configurations AND Execution Phase
tasks.register('testBoth') {
    println 'This is executed during the configuration phase as well.'
    doFirst {
	  println 'This is executed first during the execution phase.'
	}
	doLast {
	  println 'This is executed last during the execution phase.'
	}
}
```

--------------------------------

### List tasks from a specific group with --group

Source: https://docs.gradle.org/current/userguide/command_line_interface.html

Use the `--group` option to display only tasks from a specific task group, for example 'build setup'.

```bash
$ ./gradlew tasks --group="build setup"
```

--------------------------------

### Full build script example (Groovy DSL)

Source: https://docs.gradle.org/current/userguide/writing_build_scripts_intermediate.html

Complete build.gradle example showing plugins, repositories, dependencies, application configuration, and task configuration. Includes numbered comments (1)-(5) that correspond to the breakdown sections.

```groovy
plugins {   (1)
    id 'application'
}

repositories {  (2)
    mavenCentral()
}

dependencies {  (3)
    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.9.3'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
    implementation 'com.google.guava:guava:32.1.1-jre'
}

application {   (4)
    mainClass = 'com.example.Main'
}

tasks.named('test', Test) { (5)
    useJUnitPlatform()
}

tasks.named('javadoc', Javadoc).configure {
    exclude 'app/Internal*.java'
    exclude 'app/internal/*'
}

tasks.register('zip-reports', Zip) {
    from 'Reports/'
    include '*'
    archiveFileName = 'Reports.zip'
    destinationDirectory = file('/dir')
}
```

--------------------------------

### Check JAVA_HOME on Windows with echo %JAVA_HOME%

Source: https://docs.gradle.org/current/userguide/installation.html

Use this command on Windows to display the JAVA_HOME environment variable. The example output shows a JDK 17 installation directory.

```shell
$ echo %JAVA_HOME%
```

```text
C:\Program Files\Java\jdk17.0_6
```

--------------------------------

### Change into the tutorial directory

Source: https://docs.gradle.org/current/userguide/part1_gradle_init_project.html

Changes the current directory to `authoring-tutorial`.

```bash
$ cd authoring-tutorial
```

--------------------------------

### Check JAVA_HOME on Unix with echo $JAVA_HOME

Source: https://docs.gradle.org/current/userguide/installation.html

Use this command on Unix-like systems to display the JAVA_HOME environment variable. The example output shows a JDK 17 installation directory.

```bash
$ echo $JAVA_HOME
```

```text
/Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home
```

--------------------------------

### settings.gradle - Initialization Phase Example (Groovy)

Source: https://docs.gradle.org/current/userguide/build_lifecycle_intermediate.html

This settings file sets the root project name and prints a message during the initialization phase. It is the Groovy DSL equivalent of the Kotlin example.

```groovy
rootProject.name = 'basic'
println 'This is executed during the initialization phase.'
```

--------------------------------

### Inject BuildInvocationDetails in Groovy DSL

Source: https://docs.gradle.org/current/userguide/service_injection.html

Groovy DSL example for a task that injects BuildInvocationDetails via constructor and prints the build start time. The service is only available via @Inject.

```groovy
abstract class ReportBuildStartTask extends DefaultTask {
    private BuildInvocationDetails invocationDetails

    @Inject //@javax.inject.Inject
    ReportBuildStartTask(BuildInvocationDetails invocationDetails) {
        this.invocationDetails = invocationDetails
    }

    @TaskAction
    void report() {
        def started = new Date(invocationDetails.buildStartedTime)
        println("Build started at $started")
    }
}

tasks.register("reportBuildStart", ReportBuildStartTask) {}
```

--------------------------------

### Change into tutorial directory

Source: https://docs.gradle.org/current/userguide/part1_gradle_init.html

Changes the current directory to 'tutorial'.

```bash
$ cd tutorial
```

--------------------------------

### Inject BuildInvocationDetails in Kotlin DSL

Source: https://docs.gradle.org/current/userguide/service_injection.html

Kotlin DSL example for a task that injects BuildInvocationDetails via constructor and prints the build start time. The service is only available via @Inject.

```kotlin
abstract class ReportBuildStartTask
@Inject constructor(private var invocationDetails: BuildInvocationDetails) : DefaultTask() {

    @TaskAction
    fun report() {
        val started = Date(invocationDetails.buildStartedTime)
        println("Build started at $started")
    }
}

tasks.register("reportBuildStart", ReportBuildStartTask::class) {}
```

--------------------------------

### my-app/app/build.gradle.kts - applying included plugin

Source: https://docs.gradle.org/current/userguide/composite_builds.html

Kotlin DSL build script that applies the 'com.example.hello' plugin from the included build.

```kotlin
plugins {
    id("application")
    id("com.example.hello") // from the Included Build in pluginManagement
}
```

--------------------------------

### Basic IdeaModule configuration example

Source: https://docs.gradle.org/current/kotlin-dsl/gradle/org.gradle.plugins.ide.idea.model/-idea-module/index.html

Shows a typical configuration of the IdeaModule model with a blend of most possible properties. Typically you don't have to configure this model directly because Gradle configures it for you. The example introduces a 'performanceTestCompile' configuration and demonstrates setting path variables, source dirs, output dirs, SDK, scopes, content root, and download options.

```groovy
plugins {
    id 'java'
    id 'idea'
}

//for the sake of this example, let's introduce a 'performanceTestCompile' configuration
configurations {
  performanceTestCompile
  performanceTestCompile.extendsFrom(testCompile)
}

dependencies {
  //performanceTestCompile "some.interesting:dependency:1.0"
}

idea {

  //if you want parts of paths in resulting files (*.iml, etc.) to be replaced by variables (Files)
  pathVariables GRADLE_HOME: file('~/cool-software/gradle')

  module {
    //if for some reason you want to add an extra sourceDirs
    sourceDirs += file('some-extra-source-folder')

    //and some extra test source dirs
    testSources.from(file('some-extra-test-dir'))

    //and some extra resource dirs
    resourceDirs += file('some-extra-resource-dir')

    //and some extra test resource dirs
    testResources.from(file('some-extra-test-resource-dir'))

    //and hint to mark some of existing source dirs as generated sources
    generatedSourceDirs += file('some-extra-source-folder')

    //and some extra dirs that should be excluded by IDEA
    excludeDirs += file('some-extra-exclude-dir')

    //if you don't like the name Gradle has chosen
    name = 'some-better-name'

    //if you prefer different output folders
    inheritOutputDirs = false
    outputDir = file('muchBetterOutputDir')
    testOutputDir = file('muchBetterTestOutputDir')

    //if you prefer different SDK than the one inherited from IDEA project
    jdkName = '1.6'

    //put our custom test dependencies onto IDEA's TEST scope
    scopes.TEST.plus += [ configurations.performanceTestCompile ]

    //if 'content root' (as IDEA calls it) of the module is different
    contentRoot = file('my-module-content-root')

    //if you love browsing Javadoc
    downloadJavadoc = true

    //and hate reading sources :)
    downloadSources = false
  }
}
```

--------------------------------

### Set JAVA_HOME and verify it

Source: https://docs.gradle.org/current/userguide/troubleshooting.html

Use these commands to set the JAVA_HOME environment variable to the location of your Java installation and then echo it to verify the value. The example uses a Corretto JDK path on macOS.

```bash
$ export JAVA_HOME=/Users/user/Library/Java/JavaVirtualMachines/corretto-22.0.1/Contents/Home
$ echo $JAVA_HOME

```

--------------------------------

### Run multiple tasks sequentially

Source: https://docs.gradle.org/current/userguide/command_line_interface_basics.html

Example of running 'clean' first, then 'build'.

```text
gradle clean build
```

--------------------------------

### Resolve path relative to settings directory using layout.settingsDirectory (Groovy)

Source: https://docs.gradle.org/current/userguide/working_with_files.html

Groovy equivalent of the Kotlin example. Use layout.settingsDirectory.file("shared/config.xml").asFile to get a File relative to the settings directory.

```groovy
File configFile = layout.settingsDirectory.file("shared/config.xml").asFile
```

--------------------------------

### Create license-plugin directory and navigate into it

Source: https://docs.gradle.org/current/userguide/part3_multi_project_builds.html

Commands to create a new directory 'license-plugin' in the 'gradle' directory and navigate into it.

```bash
$ cd gradle

```

```bash
$ mkdir license-plugin

```

```bash
$ cd license-plugin

```

--------------------------------

### Use the<T>() for one-line extension configuration in build.gradle.kts

Source: https://docs.gradle.org/current/userguide/kotlin_dsl.html

Use the<T>() function to get a reference to an extension without configuring it, or for one-line configuration. This example configures the 'main' source set's Java source directory.

```kotlin
the<SourceSetContainer>()["main"].java.srcDir("src/main/java")
```

--------------------------------

### Plugin DSL syntax examples

Source: https://docs.gradle.org/current/userguide/plugins_intermediate.html

Shows the general syntax of the plugins{} block, including applying by name and by id with optional version.

```text
plugins {
    application                                     // by name
    java                                            // by name
    id("java")                                      // by id - recommended
    id("org.jetbrains.kotlin.jvm") version "1.9.0"  // by id - recommended
}
```

--------------------------------

### get(ResultHandler<? super T>)

Source: https://docs.gradle.org/current/javadoc/org/gradle/tooling/ModelBuilder.html

Starts fetching the model, passing the result to the given handler when complete. This method returns immediately, and the result is later passed to the given handler's `ResultHandler.onComplete(Object)` method.

```APIDOC
## get(ResultHandler<? super T>)

### Description
Starts fetching the model, passing the result to the given handler when complete. This method returns immediately, and the result is later passed to the given handler's `ResultHandler.onComplete(Object)` method.

### Method
get

### Signature
`void get(ResultHandler<? super T> handler) throws IllegalStateException`

### Parameters
- **handler** (ResultHandler<? super T>) - Required - The handler to receive the result.

### Throws
- `IllegalStateException` - When the connection has been closed or is closing.
```

--------------------------------

### TaskStartEvent Interface

Source: https://docs.gradle.org/current/javadoc/org/gradle/tooling/events/task/TaskStartEvent.html

The TaskStartEvent interface is part of the Gradle Tooling API. It is used to receive notifications when a task starts. Users can implement listeners that receive this event and call the inherited methods to get event details.

```APIDOC
## Interface TaskStartEvent

### Description
An event that informs about a task having started its execution.

### Since
2.5

### Superinterfaces
- ProgressEvent
- StartEvent
- TaskProgressEvent

### Inherited Methods

#### getDisplayName()
- **Return type**: String
- **Description**: Returns the display name of the event. (Inherited from ProgressEvent)

#### getEventTime()
- **Return type**: long
- **Description**: Returns the time of the event. (Inherited from ProgressEvent)

#### getDescriptor()
- **Return type**: TaskOperationDescriptor
- **Description**: Returns the descriptor of the task operation. (Inherited from TaskProgressEvent)

### Usage
This interface is typically used in a ProgressListener implementation to receive task start events. Example:

```java
import org.gradle.tooling.events.ProgressListener;
import org.gradle.tooling.events.task.TaskStartEvent;

public class MyProgressListener implements ProgressListener {
    @Override
    public void statusChanged(org.gradle.tooling.events.ProgressEvent event) {
        if (event instanceof TaskStartEvent) {
            TaskStartEvent startEvent = (TaskStartEvent) event;
            System.out.println("Task started: " + startEvent.getDisplayName());
        }
    }
}
```
```

--------------------------------

### Run a single task

Source: https://docs.gradle.org/current/userguide/command_line_interface_basics.html

Example of running a task named 'build'.

```text
gradle build
```

--------------------------------

### Hello World binary plugin in Groovy (build.gradle)

Source: https://docs.gradle.org/current/userguide/binary_plugin_advanced.html

A minimal binary plugin example in Groovy that implements Plugin<Project> and registers a task named 'ScriptPlugin' that prints 'Hello world from the build file!'. The plugin is applied with 'apply plugin: SamplePlugin'.

```groovy
class SamplePlugin implements Plugin<Project> { (1)
    void apply(Project project) {   (2)
        project.tasks.register("ScriptPlugin") {
            doLast {
                println("Hello world from the build file!")
            }
        }
    }
}

apply plugin: SamplePlugin (3)
```

--------------------------------

### Command Line: Set JDK Home with -Dorg.gradle.java.home

Source: https://docs.gradle.org/current/userguide/build_environment.html

Use this command to specify the JDK installation directory via the command line. This has the highest precedence among configuration methods. The example includes the --scan flag.

```text
$ ./gradlew exampleTask -Dorg.gradle.java.home=/path/to/your/java/home --scan
```

--------------------------------

### Run the hello task with Gradle

Source: https://docs.gradle.org/current/userguide/writing_tasks_intermediate.html

Executes the 'hello' task with the -q flag to suppress output except for the task's own prints.

```bash
$ ./gradlew -q hello
```

--------------------------------

### AWS S3 IAM policy for publishing artifacts

Source: https://docs.gradle.org/current/userguide/upgrading_version_4.html

IAM policy example that grants the necessary permissions for publishing to an S3 bucket. Requires s3:PutObjectAcl and s3:PutObjectVersionAcl (if versioning is enabled) starting with Gradle 4.10.

```json
{
    "Version":"2012-10-17",
    "Statement":[
        // ...
        {
            "Effect":"Allow",
            "Action":[
                "s3:PutObject", // necessary for uploading objects
                "s3:PutObjectAcl", // required starting with this release
                "s3:PutObjectVersionAcl" // if S3 bucket versioning is enabled
            ],
            "Resource":"arn:aws:s3:::myCompanyBucket/*"
        }
    ]
}
```

--------------------------------

### WorkItemStartEvent Interface

Source: https://docs.gradle.org/current/javadoc/org/gradle/tooling/events/work/WorkItemStartEvent.html

The WorkItemStartEvent interface is part of the Gradle Tooling API. It is used to receive notifications when a work item starts execution. Users can implement listeners that receive this event and access its inherited methods to get details about the event.

```APIDOC
## Interface WorkItemStartEvent

### Description
An event that informs about a work item having started its execution.

### Since
5.1

### Superinterfaces
- ProgressEvent
- StartEvent
- WorkItemProgressEvent

### Inherited Methods

#### getDisplayName()
- **Return Type**: String
- **Description**: Returns the display name of the progress event. (Inherited from ProgressEvent)

#### getEventTime()
- **Return Type**: long
- **Description**: Returns the timestamp of the event. (Inherited from ProgressEvent)

#### getDescriptor()
- **Return Type**: WorkItemDescriptor
- **Description**: Returns the descriptor of the work item that started. (Inherited from WorkItemProgressEvent)

```

--------------------------------

### Hello World binary plugin in Kotlin (build.gradle.kts)

Source: https://docs.gradle.org/current/userguide/binary_plugin_advanced.html

A minimal binary plugin example in Kotlin that implements Plugin<Project> and registers a task named 'ScriptPlugin' that prints 'Hello world from the build file!'. The plugin is applied with apply<SamplePlugin>().

```kotlin
abstract class SamplePlugin : Plugin<Project> { (1)
    override fun apply(project: Project) {  (2)
        project.tasks.register("ScriptPlugin") {
            doLast {
                println("Hello world from the build file!")
            }
        }
    }
}

apply<SamplePlugin>() (3)
```

--------------------------------

### Include GitLab Gradle template

Source: https://docs.gradle.org/current/userguide/gitlab-ci.html

Include the official GitLab Gradle CI template to get a starting pipeline with build, test, and deploy stages. The template uses the gradle:alpine image and configures a .gradle/ cache keyed by branch.

```yaml
include:
  - template: Gradle.gitlab-ci.yml
```

--------------------------------

### Activating profiles with Gradle command line

Source: https://docs.gradle.org/current/userguide/migrating_from_maven.html

Shows how to run the build with the default profile and with the 'test' profile using the -PbuildProfile=test flag. The output shows the message printed by the greeting task.

```bash
$ ./gradlew gradle greeting
```

```text
foobar
```

```bash
$ ./gradlew -PbuildProfile=test greeting
```

```text
testing 1 2 3
```

--------------------------------

### beforeSettings callback in Kotlin init script

Source: https://docs.gradle.org/current/userguide/build_lifecycle.html

Use in an init script to tweak start parameters or log early info before settings are loaded. The example checks the CI environment variable and enables or disables parallel project execution accordingly.

```kotlin
// 1. beforeSettings: tweak start parameters / log early info
// before the build settings have been loaded and evaluated.
gradle.beforeSettings {
    println("[beforeSettings] gradleUserHome = ${gradle.gradleUserHomeDir}")

    // Example: default to --parallel if an env var is set
    if (System.getenv("CI") == "true") {
        println("[beforeSettings] Enabling parallel execution on CI")
        gradle.startParameter.isParallelProjectExecutionEnabled = true
    } else {
        println("[beforeSettings] Disabling parallel execution, not on CI")
        gradle.startParameter.isParallelProjectExecutionEnabled = false
    }
}
```

--------------------------------

### Example verbose build output showing task states

Source: https://docs.gradle.org/current/userguide/gradle_optimizations.html

Example output from running the verbose command, showing tasks marked UP-TO-DATE or NO-SOURCE.

```text
> Task :buildSrc:generateExternalPluginSpecBuilders UP-TO-DATE
> Task :buildSrc:extractPrecompiledScriptPluginPlugins UP-TO-DATE
> Task :buildSrc:compilePluginsBlocks UP-TO-DATE
> Task :buildSrc:generatePrecompiledScriptPluginAccessors UP-TO-DATE
> Task :buildSrc:generateScriptPluginAdapters UP-TO-DATE
> Task :buildSrc:compileKotlin UP-TO-DATE
> Task :buildSrc:compileJava NO-SOURCE
> Task :buildSrc:compileGroovy NO-SOURCE
> Task :buildSrc:pluginDescriptors UP-TO-DATE
> Task :buildSrc:processResources UP-TO-DATE
> Task :buildSrc:classes UP-TO-DATE
> Task :buildSrc:jar UP-TO-DATE
> Task :list:compileJava UP-TO-DATE
> Task :utilities:compileJava UP-TO-DATE
> Task :app:compileJava UP-TO-DATE

BUILD SUCCESSFUL in 374ms
12 actionable tasks: 12 up-to-date
```

--------------------------------

### getAsBytes()

Source: https://docs.gradle.org/current/javadoc/org/gradle/process/ExecOutput.StandardStreamContent.html

Gets a provider for the standard stream's content that returns it as a byte array. The external process is executed only once and only when the value is requested for the first time. If starting the process results in an exception, the exception is permanently propagated to callers of Provider.get(), getOrElse(), getOrNull(), and isPresent().

```APIDOC
## getAsBytes()

### Description
Gets a provider for the standard stream's content that returns it as a byte array. The external process is executed only once and only when the value is requested for the first time. If starting the process results in an exception, the exception is permanently propagated to callers of Provider.get(), Provider.getOrElse(T), Provider.getOrNull(), and Provider.isPresent().

### Method
`Provider<byte[]> getAsBytes()`

### Return Type
`Provider<byte[]>` - A provider that returns the standard stream content as a byte array.

### Since
7.5

```

--------------------------------

### Example output of help --task libs

Source: https://docs.gradle.org/current/userguide/command_line_interface.html

Example output from the `help --task libs` command, showing detailed task information for the 'libs' task.

```text
Detailed task information for libs

Paths
     :api:libs (registered in build file 'api/build.gradle')
     :webapp:libs (registered in build file 'webapp/build.gradle')

Type
     Task (org.gradle.api.Task)

Options
     --rerun     Causes the task to be re-run even if up-to-date.

Description
     Builds the JAR

Group
     build
```
Tokens:
Raw