JAR-Erstellung

Elide erstellt und liest JAR-Dateien direkt mit elide jar und baut sie als Projektartefakte.

Erstellen, auflisten und entpacken

jar-Optionen folgen nach --:

elide jar -- --create --file app.jar -C out .                              # create
elide jar -- --list --file app.jar                                         # list
elide jar -- --extract --file app.jar --dir extracted                      # extract
elide jar -- --create --file app.jar --main-class com.example.Main -C out . # executable JAR
elide jar -- -help

Kompilieren und ein JAR erstellen

elide javac --jar target/app.jar -- src/Main.java src/Util.java
elide javac --jar target/app.jar --manifest src/MANIFEST.MF -- src/Main.java

Projektartefakte

amends "elide:project.pkl"
import "elide:Jvm.pkl" as Jvm

artifacts {
  ["app"] = new Jvm.Jar {
    name = "app"
    options {
      entrypoint = "com.example.Main"
    }
  }
}

elide build schreibt nach .dev/artifacts/jar/<name>/. Das JAR enthält die Klassen und Ressourcen aller Source-Sets, die keine Test-Sets sind.

Jvm.Jar

artifacts {
  ["app"] = new Jvm.Jar {
    sources { "main" }
    excludes {
      "com.example.internal"   // a package and its subpackages
      "**/*.proto"             // a path glob
    }
    manifest {
      ["Implementation-Vendor"] = "Example"
    }
    resources {
      "LICENSE.txt"
      new { from = "config"; into = "META-INF/config" }
    }
  }
}

Quell- und Javadoc-JARs

artifacts {
  ["sources"] = new Jvm.SourceJar {
    classifier = "sources"
    excludes { "**/internal/**" }
  }
  ["javadoc"] = new Jvm.JavadocJar {
    windowTitle = "Example API"
    links { "https://docs.oracle.com/en/java/javase/25/docs/api/" }
    groups {
      ["Core"] { "com.example.core" }
    }
  }
}

Quellen mit Kotlin werden mit Dokka statt mit javadoc dokumentiert, einschließlich des Java-Codes daneben; generator = "javadoc" dokumentiert nur die Java-Dateien. Dokka läuft als separater JVM-Prozess. Elide löst seine JARs beim ersten Bau eines Kotlin-Javadoc-JARs aus Maven auf und speichert sie im lokalen Maven-Repository, daher braucht dieser erste Build Netzwerkzugriff. Bei jedem Build ruft Dokka außerdem die Paketlisten hinter seinen Links zum JDK, zur Standardbibliothek und zu links ab; --offline überspringt diese Abfragen. Dokka liest sources, links und excludes (ein ausgeschlossenes Paket und seine Unterpakete werden ausgelassen); groups und die Titel gelten nur für javadoc, und Elide warnt, wenn für Dokka Titel gesetzt sind.

Ausführbare Anwendungsdistributionen

Eine Jvm.JvmApplication ist ein ausführbarer Verzeichnisbaum wie beim application-Plugin von Gradle: Laufzeit-JARs in lib/, Startskripte in bin/ und optional Archive.

artifacts {
  ["dist"] = new Jvm.JvmApplication {
    from { "app" }
    entrypoint = "com.example.Main"
    defaultJvmArgs { "-Xmx512m" }
    contents {
      new { from = "config"; into = "etc" }
    }
    options {
      archives { "zip"; "tar" }
    }
  }
}

• elide run startet den installierten Baum mit den JVM-Optionen der Skripte.
• Die Skripte lesen außerdem JAVA_OPTS und <NAME>_OPTS (sample-app → SAMPLE_APP_OPTS).
• Das POSIX-Skript folgt symbolischen Links auf sich selbst; unter Windows führen Sie das Skript direkt oder über PATH aus.
• name, version (beim Archivieren) und jedes into müssen auf allen Plattformen gültige Dateinamen sein: kein /, \, :*?"<>|, keine Steuerzeichen, kein Punkt oder Leerzeichen am Ende und keine Windows-Gerätenamen wie NUL. Ungültige Namen lassen den Build fehlschlagen, bevor er etwas schreibt.

Workspace-Mitglieder verwenden das Jvm.Jar eines Geschwisterprojekts mit project("core"); siehe Workspaces.