Plugin Gradle

Les plugins dev.elide.settings et dev.elide font exécuter elide javac aux tâches JavaCompile de Gradle, et ajoutent des tâches de formatage et d’export des dépendances. Gradle garde la résolution des dépendances, les tests et le packaging.

Prérequis

	Version
Gradle	7.6.4 ou ultérieure
JDK qui exécute Gradle	17 ou ultérieure
Plugins	1.2.0, depuis Maven Central
Elide	1.6

Installation

settings.gradle.kts ajoute Maven Central aux dépôts de plugins et choisit l’environnement d’exécution Elide pour tout le build :

import dev.elide.gradle.ElideRuntimeMode

pluginManagement {
    repositories {
        mavenCentral()
        gradlePluginPortal()
    }
}

plugins {
    id("dev.elide.settings") version "1.2.0"
}

elide {
    runtime {
        mode = ElideRuntimeMode.MANAGED
        version = "1.6.0"
    }
}

Chaque projet qui doit compiler avec Elide applique dev.elide, sans version :

// build.gradle.kts
plugins {
    id("dev.elide")
    java
}

elide {
    compiler = true
}

Sous Gradle 7.6, configurez l’extension de settings avec configure<dev.elide.gradle.ElideSettingsExtension> { runtime { … } }.

Choix de l’environnement d’exécution

`mode`	Utilise
`AUTO` (par défaut)	`runtime.executable` s’il est défini, puis `elide` dans le `PATH` si sa version est au moins `version`, puis l’environnement d’exécution géré
`PATH`	`elide` dans le `PATH` ; échoue s’il est plus ancien que `version`
`MANAGED`	Télécharge `version` une fois dans `<GRADLE_USER_HOME>/caches/dev.elide/runtimes/`, vérifie son SHA-256 et le réutilise hors ligne

elide {
    runtime {
        mode = ElideRuntimeMode.PATH
        executable = layout.projectDirectory.file("tools/elide")
    }
}

Les téléchargements gérés couvrent Linux x86_64 et arm64, macOS arm64 et Windows x86_64. Appliquer le plugin ne télécharge et n’exécute rien ; l’environnement d’exécution est préparé quand une tâche en a besoin.

Configuration

Bloc elide { } du projet :

Propriété	Par défaut	Effet
`compiler`	`true`	Compile les tâches `JavaCompile` avec `elide javac`
`persistentCompiler`	`false`	Garde jusqu’à quatre workers `elide javac` chauds pour le reste du build
`dependencyMode`	`LEGACY`	`GRADLE` : Gradle gère la résolution ; `install` doit rester désactivé
`install`	`false`	Exécute `elide install` depuis `elide.pkl` avant de compiler
`maven`	`true`	Avec `install`, ajoute `.dev/dependencies/m2` comme dépôt Maven
`manifest`	`elide.pkl`	Manifeste que lit `install`

Les propriétés Gradle remplacent le bloc le temps d’une exécution, dans les deux sens :

Propriété	Effet
`elide.builder.javac.enable=false`	Compile avec le `javac` standard
`elide.builder.maven.install.enable=true`	Force l’activation de `elide install`

./gradlew build -Pelide.builder.javac.enable=false

Tâches

Tâche	Rôle
`prepareElideRuntime`	Télécharge et vérifie l’environnement d’exécution géré
`elideInstall`	Exécute `elide install` ; ignorée sauf si `install = true`
`elideCheckFormat`	Échoue quand des fichiers `.java`, `.kt` ou `.kts` sous `src/` doivent être formatés ; ne modifie rien
`elideFormat`	Les formate sur place
`elideExportDependencies`	Écrit les coordonnées résolues et le SHA-256 de chaque source set dans `build/elide/dependencies/`

compileJava et compileTestJava gardent leurs types de tâche : la compilation incrémentale et le cache de build fonctionnent comme d’habitude.

Exemple

settings.gradle.kts
build.gradle.kts
src/main/java/com/example/HelloWorld.java
src/test/java/com/example/HelloWorldTest.java

// build.gradle.kts
plugins {
    id("dev.elide")
    java
    application
}

application {
    mainClass = "com.example.HelloWorld"
}

repositories {
    mavenCentral()
}

elide {
    compiler = true
}

dependencies {
    implementation("com.google.guava:guava:33.4.8-jre")
    testImplementation("org.junit.jupiter:junit-jupiter:5.13.4")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

tasks.test {
    useJUnitPlatform()
}

Avec le settings.gradle.kts de la section Installation :

./gradlew clean build run

> Task :prepareElideRuntime UP-TO-DATE
> Task :elideInstall SKIPPED
> Task :clean
> Task :compileJava
> Task :jar
> Task :run
Hello, World!
> Task :compileTestJava
> Task :test
> Task :build
BUILD SUCCESSFUL in 5s
Configuration cache entry stored.

La première exécution télécharge Elide dans prepareElideRuntime ; les suivantes le réutilisent.

OpenRewrite et requêtes de dépendances

Pour les projets dotés d’un elide.pkl, voir OpenRewrite et Index du code des dépendances. Le plugin Gradle n’ajoute pas de tâches de réécriture ou d’index de code ; elideExportDependencies exporte des coordonnées et des sommes de contrôle, mais sa sortie n’est pas une entrée de elide index. Lisez la limite de la configuration du projet avant d’utiliser ces commandes à côté de Gradle.

Limites

Seule la compilation Java passe par Elide. Kotlin (compileKotlin) utilise le compilateur du plugin Gradle de Kotlin.
persistentCompiler ne prend pas en charge forkOptions.jvmArgs.
MANAGED n’est pas disponible sur les Mac Intel ; utilisez-y PATH.
elideFormat ne couvre que les sources sous src/.