Assemblage JAR

Elide crée et lit directement les fichiers JAR avec elide jar, et les construit comme artefacts de projet.

Créer, lister et extraire

Les options de jar se placent après -- :

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

Compiler et créer un JAR

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

Artefacts de projet

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

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

elide build écrit dans .dev/artifacts/jar/<name>/. Le JAR contient les classes et ressources de chaque source set qui n’est pas un source set de test.

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" }
    }
  }
}

JAR de sources et de Javadoc

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" }
    }
  }
}

Les sources qui contiennent du Kotlin sont documentées avec Dokka au lieu de javadoc, y compris le code Java qui les accompagne ; generator = "javadoc" ne documente que les fichiers Java. Dokka s’exécute dans un processus JVM distinct. Elide résout ses JAR depuis Maven la première fois qu’un JAR Javadoc Kotlin est construit et les met en cache dans le dépôt Maven local : ce premier build nécessite donc un accès réseau. À chaque build, Dokka récupère aussi les listes de paquets derrière ses liens vers le JDK, la bibliothèque standard et links ; --offline saute ces requêtes. Dokka lit sources, links et excludes (un paquet exclu et ses sous-paquets sont omis) ; groups et les titres ne s’appliquent qu’à javadoc, et Elide émet un avertissement quand des titres sont définis pour Dokka.

Distributions d’applications exécutables

Un Jvm.JvmApplication est une arborescence exécutable, comme avec le plugin application de Gradle : les JAR d’exécution dans lib/, les scripts de démarrage dans bin/ et des archives facultatives.

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 lance l’arborescence installée avec les options JVM des scripts.
• Les scripts lisent aussi JAVA_OPTS et <NAME>_OPTS (sample-app → SAMPLE_APP_OPTS).
• Le script POSIX suit les liens symboliques qui pointent vers lui ; sous Windows, exécutez le script directement ou via PATH.
• name, version (lors de l’archivage) et chaque into doivent être des noms de fichier valides sur toutes les plateformes : pas de /, \, :*?"<>|, de caractères de contrôle, de point ou d’espace final, ni de noms de périphérique Windows comme NUL. Un nom invalide fait échouer le build avant toute écriture.

Les membres d’un espace de travail utilisent le Jvm.Jar d’un projet voisin avec project("core") ; voir Espaces de travail.