# Exportación de POM

`elide project export` convierte un proyecto `elide.pkl` en un modelo que leen otras herramientas. `--format=pom`
escribe un `pom.xml` de Maven, que compila cualquier instalación de Maven 3.9+.

## Exportar

```bash
elide project export --format=pom > pom.xml
elide project export --format=json          # resolved manifest
elide project export --format=intellij      # IntelliJ workspace model
elide project export -p app --format=pom    # another project directory
```

Pase el formato como `--format=<value>`; la salida va a stdout.

| Formato | Contenido |
| --- | --- |
| `json` (predeterminado) | El manifiesto tras la evaluación de Pkl |
| `pom` | Un POM de Maven: coordenadas, dependencias con sus ámbitos, versión del compilador, raíces de fuentes |
| `intellij` | Módulos por conjunto de fuentes, raíces de contenido y de fuentes, dependencias de bibliotecas, nivel del JDK |

### Qué contiene el POM

| `elide.pkl` | `pom.xml` |
| --- | --- |
| `name` | `<groupId>`, `<artifactId>` y `<name>` (un miembro de un espacio de trabajo toma el nombre del espacio de trabajo como `<groupId>`) |
| `version` | `<version>`; `0.0.0` si no está definida |
| `jvm.target`, `jvm.java.release` | `maven.compiler.release`, `.source`, `.target` |
| `packages`, `modules` | Ámbito compile |
| `compileOnly`, `devPackages`, `processors` | `provided` |
| `runtimeOnly` | `runtime` |
| `testPackages` | `test` |
| Una ruta a un JAR local | Ámbito `system` con una ruta `${project.basedir}` |
| Conjuntos de fuentes | `<sourceDirectory>`, `<testSourceDirectory>`; raíces adicionales mediante `build-helper-maven-plugin` |
| Miembros del espacio de trabajo | `<modules>` en la raíz, `<parent>` en cada miembro |
| Un proyecto hermano en `Jar.from` | Sus `packages`, `modules` y `runtimeOnly`, salvo que ya figuren |

No se exportan: `exclusions`, `substitutions` ni `kotlinPlugins`. Los repositorios declarados en el manifiesto sí se
exportan.

## Compilar el POM

Apunte `JAVA_HOME` al directorio que contiene `bin/elide`; sus `bin/java` y `bin/javac` ejecutan Maven, su compilador
y las JVM de prueba que lanza aparte como lo haría un JDK 25:

```bash
export JAVA_HOME="$(dirname "$(dirname "$(readlink -f "$(command -v elide)")")")"
mvn package
```

Para compilar con `elide javac` y `elide kotlinc` dentro de un POM existente, use el
[Plugin de Maven](/docs/build-tools-maven).

## Ejemplo

```pkl
amends "elide:project.pkl"

name = "hello"
version = "1.0.0"

dependencies {
  maven {
    packages { "com.google.guava:guava:33.4.8-jre" }
    testPackages { "org.junit.jupiter:junit-jupiter:5.13.4" }
  }
}

jvm {
  main = "com.example.Hello"
  target = 17
}
```

```bash
elide project export --format=pom > pom.xml
```

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>hello</groupId>
  <artifactId>hello</artifactId>
  <version>1.0.0</version>
  <name>hello</name>
  <properties>
    <maven.compiler.release>17</maven.compiler.release>
    <maven.compiler.target>17</maven.compiler.target>
    <maven.compiler.source>17</maven.compiler.source>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>33.4.8-jre</version>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.13.4</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <sourceDirectory>src/main/java</sourceDirectory>
    <testSourceDirectory>src/test/java</testSourceDirectory>
  </build>
</project>
```

## Límites

- La exportación es unidireccional: Elide nunca vuelve a leer el archivo generado. Regenérelo después de cambiar
  `elide.pkl`.
- `name` se convierte en las coordenadas. Un nombre con espacios u otros caracteres que Maven rechaza requiere editar
  a mano `<groupId>` y `<artifactId>`.
- Solo se declara `build-helper-maven-plugin`. Las fuentes de Kotlin necesitan que se añada un compilador de Kotlin a
  la compilación, como [el de Elide](/docs/build-tools-maven).
- No se añaden las dependencias de prueba integradas de Elide; declare los frameworks de pruebas en `testPackages`.
