Ensamblado de JAR

Elide crea y lee archivos JAR directamente con elide jar, y los compila como artefactos del proyecto.

Crear, listar y extraer

Las opciones de jar van después de --:

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

Compilar y crear 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

Artefactos del proyecto

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

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

elide build escribe en .dev/artifacts/jar/<name>/. El JAR contiene las clases y los recursos de todos los conjuntos de fuentes que no son de pruebas.

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

Las fuentes que incluyen Kotlin se documentan con Dokka en lugar de javadoc, que cubre también el código Java que las acompaña; generator = "javadoc" documenta solo los archivos Java. Dokka se ejecuta como un proceso JVM aparte. Elide resuelve sus JAR desde Maven la primera vez que se compila un JAR de Javadoc de Kotlin y los guarda en caché en el repositorio Maven local, así que esa primera compilación necesita acceso a la red. En cada compilación, Dokka también descarga las listas de paquetes de sus enlaces al JDK, a la biblioteca estándar y a links; --offline omite esas consultas. Dokka lee sources, links y excludes (un paquete excluido y sus subpaquetes quedan fuera); groups y los títulos solo se aplican a javadoc, y Elide avisa cuando se definen títulos para Dokka.

Distribuciones de aplicaciones ejecutables

Un Jvm.JvmApplication es un árbol ejecutable, como el plugin application de Gradle: los JAR de ejecución en lib/, los scripts de inicio en bin/ y archivos comprimidos opcionales.

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 inicia el árbol instalado con las opciones de la JVM de los scripts.
• Los scripts también leen JAVA_OPTS y <NAME>_OPTS (sample-app → SAMPLE_APP_OPTS).
• El script POSIX sigue los enlaces simbólicos a sí mismo; en Windows, ejecute el script directamente o mediante PATH.
• name, version (al generar archivos comprimidos) y cada into deben ser nombres de archivo válidos en todas las plataformas: sin /, \, :*?"<>|, caracteres de control, punto o espacio al final, ni nombres de dispositivo de Windows como NUL. Los nombres no válidos hacen fallar la compilación antes de que escriba nada.

Los miembros de un espacio de trabajo usan el Jvm.Jar de un proyecto hermano con project("core"); consulte Espacios de trabajo.