Gradle-Plugin

Die Plugins dev.elide.settings und dev.elide lassen die JavaCompile-Tasks von Gradle elide javac ausführen und fügen Tasks für Formatierung und Abhängigkeitsexport hinzu. Abhängigkeitsauflösung, Tests und Packaging bleiben bei Gradle.

Voraussetzungen

	Version
Gradle	7.6.4 oder neuer
JDK, das Gradle ausführt	17 oder neuer
Plugins	1.2.0, aus Maven Central
Elide	1.6

Installation

settings.gradle.kts fügt Maven Central zu den Plugin-Repositorys hinzu und wählt die Elide-Laufzeit für den gesamten 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"
    }
}

Jedes Projekt, das mit Elide kompilieren soll, wendet dev.elide ohne Version an:

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

elide {
    compiler = true
}

Unter Gradle 7.6 konfigurieren Sie die Settings-Erweiterung mit configure<dev.elide.gradle.ElideSettingsExtension> { runtime { … } }.

Laufzeitauswahl

`mode`	Verwendet
`AUTO` (Standard)	`runtime.executable`, falls gesetzt, dann `elide` im `PATH`, sofern es mindestens `version` meldet, dann die verwaltete Laufzeit
`PATH`	`elide` im `PATH`; schlägt fehl, wenn es älter als `version` ist
`MANAGED`	Lädt `version` einmal nach `<GRADLE_USER_HOME>/caches/dev.elide/runtimes/` herunter, prüft die SHA-256 und nutzt sie offline weiter

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

Verwaltete Downloads gibt es für Linux x86_64 und arm64, macOS arm64 und Windows x86_64. Das Anwenden des Plugins lädt nichts herunter und führt nichts aus; die Laufzeit wird vorbereitet, wenn ein Task sie braucht.

Konfiguration

Der elide { }-Block des Projekts:

Eigenschaft	Standard	Wirkung
`compiler`	`true`	`JavaCompile`-Tasks mit `elide javac` kompilieren
`persistentCompiler`	`false`	Bis zu vier `elide javac`-Worker für den Rest des Builds warm halten
`dependencyMode`	`LEGACY`	`GRADLE`: Gradle übernimmt die Auflösung; `install` muss aus bleiben
`install`	`false`	Vor dem Kompilieren `elide install` aus `elide.pkl` ausführen
`maven`	`true`	Mit `install` wird `.dev/dependencies/m2` als Maven-Repository hinzugefügt
`manifest`	`elide.pkl`	Manifest, das `install` liest

Gradle-Properties überschreiben den Block für einen Lauf, in beide Richtungen:

Property	Wirkung
`elide.builder.javac.enable=false`	Mit dem regulären `javac` kompilieren
`elide.builder.maven.install.enable=true`	`elide install` erzwingen

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

Tasks

Task	Funktion
`prepareElideRuntime`	Lädt die verwaltete Laufzeit herunter und prüft sie
`elideInstall`	Führt `elide install` aus; übersprungen, sofern nicht `install = true`
`elideCheckFormat`	Schlägt fehl, wenn `.java`-, `.kt`- oder `.kts`-Dateien unter `src/` formatiert werden müssen; ändert nichts
`elideFormat`	Formatiert sie an Ort und Stelle
`elideExportDependencies`	Schreibt aufgelöste Koordinaten und SHA-256 je Source-Set nach `build/elide/dependencies/`

compileJava und compileTestJava behalten ihre Task-Typen, daher funktionieren inkrementelles Kompilieren und der Build-Cache wie gewohnt.

Beispiel

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()
}

Mit der settings.gradle.kts aus 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.

Der erste Lauf lädt Elide in prepareElideRuntime herunter; spätere Läufe verwenden es wieder.

OpenRewrite und Abhängigkeitsabfragen

Für Projekte mit einer elide.pkl siehe OpenRewrite und Codeindex für Abhängigkeiten. Das Gradle-Plugin fügt keine Tasks für Rewrite oder den Codeindex hinzu; elideExportDependencies exportiert Koordinaten und Prüfsummen, aber seine Ausgabe ist keine Eingabe für elide index. Lesen Sie die Grenze der Projekteinrichtung, bevor Sie diese Befehle neben Gradle einsetzen.

Einschränkungen

Nur die Java-Kompilierung läuft über Elide. Kotlin (compileKotlin) nutzt den Compiler des Kotlin-Gradle-Plugins.
persistentCompiler unterstützt forkOptions.jvmArgs nicht.
MANAGED ist auf Intel-Macs nicht verfügbar; verwenden Sie dort PATH.
elideFormat erfasst nur Quellen unter src/.