Publicación en Maven

elide publish compila los JAR de una biblioteca, escribe un POM para quienes la consumen y los publica en un repositorio Maven: el local por defecto, un repositorio del equipo con --to, o Maven Central a través del Central Publisher Portal. Después, Maven, Gradle y otros proyectos de Elide dependen de ella como de cualquier otro artefacto. El bloque publishing de elide.pkl lo configura; no hay plugins que añadir.

Instalar en local

Una publicación necesita un groupId, la version del proyecto y un artefacto Jvm.Jar:

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

name = "greeter"
version = "1.0.0"
description = "Greets people."

artifacts {
  ["lib"] = new Jvm.Jar {}
}

publishing {
  maven {
    groupId = "dev.example"
  }
}

elide publish

Elide compila el JAR (reutiliza las salidas que están al día), escribe el POM e instala ambos como dev.example:greeter:1.0.0 en ~/.m2/repository, con maven-metadata-local.xml. El artifactId es por defecto el nombre del proyecto. Volver a instalar la misma versión la reemplaza, así que un consumidor en la misma máquina recibe cada cambio. Desde Maven:

<dependency>
  <groupId>dev.example</groupId>
  <artifactId>greeter</artifactId>
  <version>1.0.0</version>
</dependency>

Desde Gradle:

repositories { mavenLocal() }
dependencies { implementation("dev.example:greeter:1.0.0") }

Desde otro proyecto de Elide:

dependencies {
  maven {
    packages { "dev.example:greeter:1.0.0" }
  }
}

Una instalación local no necesita red ni credenciales. localRepository instala en otro lugar; una ruta relativa se resuelve respecto al manifiesto.

Comprobar antes de publicar

elide publish --dry-run

--dry-run prepara el POM y los JAR en .dev/staging/publish/maven con nombres de archivo de Maven (greeter-1.0.0.jar, greeter-1.0.0-sources.jar, greeter-1.0.0.pom) y los lista. Los firma si la firma está activada y, para Maven Central, también escribe el paquete, de modo que muestra exactamente lo que enviaría una ejecución real. No se escribe nada en ningún repositorio.

Qué contiene el POM

El POM describe la biblioteca para quienes la consumen, no la compilación: coordenadas, los metadatos de pom y las dependencias, sin <build>, <repositories> ni rutas locales.

Por defecto, una publicación contiene todos los Jar, SourceJar y JavadocJar que declara el proyecto; artifacts elige un subconjunto por nombre de artefacto. Debe contener exactamente un Jar y cada clasificador una sola vez. Un JavadocJar sobre fuentes Kotlin se genera con Dokka (consulte Ensamblado de JAR).

Publicar en un repositorio del equipo

Dé un nombre al repositorio en repositories y publique en él por ese nombre:

publishing {
  maven {
    groupId = "dev.example"
    repositories {
      ["internal"] = "https://repo.example.dev/releases"
    }
  }
}

export ELIDE_MAVEN_INTERNAL_USERNAME=ci
export ELIDE_MAVEN_INTERNAL_PASSWORD="$REPO_TOKEN"
elide publish --to internal

Las credenciales se toman de ELIDE_MAVEN_<NAME>_USERNAME y ELIDE_MAVEN_<NAME>_PASSWORD, donde <NAME> es el nombre del repositorio en mayúsculas con cualquier otro carácter convertido en _ (my-repo → ELIDE_MAVEN_MY_REPO_…), así que el manifiesto no guarda secretos. Cada archivo se sube con sumas de verificación .md5, .sha1, .sha256 y .sha512, y se actualiza maven-metadata.xml. Funciona con Nexus, Artifactory, GitHub Packages y cualquier repositorio que acepte subidas de Maven. Una URL http:// simple que no sea localhost se rechaza sin --allow-http-repositories.

Firmar con gpg

publishing {
  maven {
    signing { gpg { keyName = "0123ABCD" } }   // `signing {}` uses gpg's default key
  }
}

Con signing establecido, una publicación remota firma cada archivo con el binario gpg (<file>.asc). Una instalación local solo firma con --sign; --no-sign desactiva la firma. gpg-agent pide la frase de contraseña; en CI, establezca ELIDE_GPG_PASSPHRASE y Elide se la pasa a gpg mediante pinentry en modo loopback. Elide nunca lee la clave por sí mismo. Si falta gpg o falla, no se publica nada.

Publicar en Maven Central

Maven Central exige metadatos en el POM, JAR de fuentes y de javadoc, firmas y una versión de lanzamiento. Una biblioteca completa:

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

name = "greeter"
version = "1.0.0"
description = "Greets people."

artifacts {
  ["lib"] = new Jvm.Jar {}
  ["sources"] = new Jvm.SourceJar {}
  ["javadoc"] = new Jvm.JavadocJar {}
}

publishing {
  maven {
    groupId = "dev.example"
    pom {
      name = "Greeter"
      url = "https://github.com/example/greeter"
      licenses { new { name = "Apache-2.0"; url = "https://www.apache.org/licenses/LICENSE-2.0" } }
      developers { new { id = "jdoe"; name = "J. Doe" } }
      scm { url = "https://github.com/example/greeter" }
    }
    repositories {
      ["central"] = new Publishing.CentralPortal {}
    }
  }
}

Cree un token de usuario en el Central Publisher Portal y publique:

export ELIDE_MAVEN_CENTRAL_USERNAME=<token user>
export ELIDE_MAVEN_CENTRAL_PASSWORD=<token password>
elide publish --to central

Antes de compilar nada, Elide comprueba los requisitos de Central e informa de todo lo que falta a la vez: name, description, url, licenses, developers y scm.url del POM, un SourceJar, un JavadocJar y una versión que no sea -SNAPSHOT. La description del POM es por defecto la del proyecto. Central siempre firma, con la clave predeterminada de gpg salvo que signing elija otra, así que --no-sign se rechaza.

Elide sube un único paquete firmado y con sumas de verificación, y espera a que el Portal lo valide. Por defecto (publishingType = "USER_MANAGED"), después usted publica el despliegue en el Portal; Elide muestra su página. Con publishingType = "AUTOMATIC", el Portal lo publica en cuanto lo valida. Si la validación falla, Elide muestra los errores del Portal. --no-wait termina justo después de la subida.

Espacios de trabajo

En un espacio de trabajo, defina la configuración compartida una sola vez en el elide.pkl raíz:

import "elide:Publishing.pkl" as Publishing

publishing {
  maven {
    groupId = "dev.example"
    pom { url = "https://github.com/example/greeter"; scm { url = "https://github.com/example/greeter" } }
    repositories { ["central"] = new Publishing.CentralPortal {} }
  }
}

Los miembros lo heredan todo salvo artifactId y artifacts, que son propios de cada proyecto; la configuración de un miembro prevalece campo a campo, y los repositorios se combinan por nombre.

Todos los proyectos se compilan, se preparan y se firman antes de publicar ninguno, así que un fallo en esa fase no publica nada. En Maven Central, todos los proyectos van en un único despliegue que el Portal valida y publica a la vez. --skip-existing también sirve para repetir un lanzamiento que falló a medias: omite lo que ya llegó y nunca omite una versión snapshot.

En CI

- run: elide publish --to central --skip-existing
  env:
    ELIDE_MAVEN_CENTRAL_USERNAME: ${{ secrets.CENTRAL_USERNAME }}
    ELIDE_MAVEN_CENTRAL_PASSWORD: ${{ secrets.CENTRAL_PASSWORD }}
    ELIDE_GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}

Importe la clave de firma en el llavero de gpg del runner en un paso anterior. Consulte Integración continua para instalar Elide en el runner.

Referencia

• elide publish: todas las opciones.
• publishing: todas las propiedades del manifiesto.
• Exportación de POM: imprime un pom.xml para la compilación en lugar de publicar.