# Plugin Maven

Avec `dev.elide:elide-maven-plugin` dans un `pom.xml`, le build compile Java avec `elide javac` et Kotlin avec
`elide kotlinc`. Maven garde la résolution des dépendances, les tests, le packaging et tous les autres plugins.

## Prérequis

| | Version |
| --- | --- |
| Maven | 3.9 ou ultérieure |
| JDK qui exécute Maven | 11 ou ultérieure |
| Elide | 1.6 ou ultérieure |

Elide doit être dans le `PATH` ; sinon, définissez `<executable>` (voir [Configuration](#configuration)).

## Choisir un artefact

| Artefact | À utiliser quand | Compile |
| --- | --- | --- |
| `elide-maven-plugin` | Nouvelle configuration, Java et Kotlin | Java et Kotlin |
| `elide-kotlin-maven-plugin` | Le build utilise déjà `kotlin-maven-plugin` | Kotlin ; Java via `maven-compiler-plugin` |
| `elide-java-compiler` | Java seul, `maven-compiler-plugin` restant tel quel | Java |

Les trois sont sur Maven Central sous `dev.elide`, version `1.0.0`.

## Installation

```xml
<build>
  <plugins>
    <plugin>
      <groupId>dev.elide</groupId>
      <artifactId>elide-maven-plugin</artifactId>
      <version>1.0.0</version>
      <extensions>true</extensions>
    </plugin>
  </plugins>
</build>
```

`<extensions>true</extensions>` est obligatoire : il remplace les liaisons de compilation par défaut. Avec lui, le
plugin ajoute `src/main/kotlin` et `src/test/kotlin` comme racines de sources, ainsi qu'une dépendance `kotlin-stdlib`
quand le POM n'en déclare aucune.

Pour remplacer `kotlin-maven-plugin` sur place, changez ses coordonnées en `dev.elide:elide-kotlin-maven-plugin:1.0.0`
et gardez sa configuration ; il accepte les mêmes paramètres.

Pour Java seul, sans nouveau plugin :

```xml
<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.15.0</version>
  <dependencies>
    <dependency>
      <groupId>dev.elide</groupId>
      <artifactId>elide-java-compiler</artifactId>
      <version>1.0.0</version>
    </dependency>
  </dependencies>
  <configuration>
    <compilerId>elide</compilerId>
  </configuration>
</plugin>
```

## Goals

Avec les extensions activées, les goals se lient au cycle de vie ; aucun n'a besoin d'une `<execution>`.

| Goal | Phase | Exécute |
| --- | --- | --- |
| `elide:kapt` | `process-sources` | Ignoré sauf si des processeurs d'annotations sont configurés |
| `elide:compile-kotlin` | `compile` | `elide kotlinc` sur les sources principales |
| `elide:compile` | `compile` | `elide javac` sur les sources principales, après Kotlin |
| `elide:test-kapt` | `process-test-sources` | Ignoré sauf si des processeurs d'annotations sont configurés |
| `elide:test-compile-kotlin` | `test-compile` | `elide kotlinc` sur les sources de test |
| `elide:test-compile` | `test-compile` | `elide javac` sur les sources de test |

`elide-kotlin-maven-plugin` a les mêmes goals, sans ceux pour Java, sous le préfixe `elide-kotlin`.

## Configuration

Tous les paramètres de `maven-compiler-plugin` et de `kotlin-maven-plugin` s'appliquent (`<release>`,
`<compilerArgs>`, `<args>`, `<jvmTarget>`, …). Un paramètre s'ajoute :

| Paramètre | Par défaut | Effet |
| --- | --- | --- |
| `executable` | `elide` dans le `PATH` | Chemin du binaire `elide` |

```xml
<plugin>
  <groupId>dev.elide</groupId>
  <artifactId>elide-maven-plugin</artifactId>
  <version>1.0.0</version>
  <extensions>true</extensions>
  <configuration>
    <executable>/opt/elide/bin/elide</executable>
  </configuration>
</plugin>
```

Avec `elide-java-compiler`, définissez plutôt `<executable>` dans la configuration de `maven-compiler-plugin`.

## Exemple

Un projet avec un objet Kotlin, une classe principale Java et un test JUnit :

```text
pom.xml
src/main/kotlin/com/example/Greeter.kt
src/main/java/com/example/Hello.java
src/test/java/com/example/GreeterTest.java
```

```xml
<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>hello</artifactId>
  <version>1.0.0</version>

  <properties>
    <maven.compiler.release>21</maven.compiler.release>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.13.4</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>dev.elide</groupId>
        <artifactId>elide-maven-plugin</artifactId>
        <version>1.0.0</version>
        <extensions>true</extensions>
      </plugin>
      <plugin>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.5.4</version>
      </plugin>
    </plugins>
  </build>
</project>
```

```bash
mvn package
```

```terminaloutput
[INFO] Added kotlin-stdlib dependency, version 2.3.21
[INFO] --- elide:1.0.0:kapt (default-kapt) @ hello ---
[INFO] No annotation processors configured, skipping kapt
[INFO] --- elide:1.0.0:compile-kotlin (default-compile-kotlin) @ hello ---
[INFO] ✅  Kotlin sources compiled to `classes` (1.3s)
[INFO] --- elide:1.0.0:compile (default-compile) @ hello ---
[INFO] Compiling 1 source file with elide [forked debug release 21] to target/classes
[INFO] --- elide:1.0.0:test-compile (default-test-compile) @ hello ---
[INFO] Compiling 1 source file with elide [forked debug release 21] to target/test-classes
[INFO] --- surefire:3.5.4:test (default-test) @ hello ---
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] --- jar:3.5.0:jar (default-jar) @ hello ---
[INFO] Building jar: target/hello-1.0.0.jar
[INFO] BUILD SUCCESS
```

## OpenRewrite et requêtes de dépendances

Pour les projets dotés d'un `elide.pkl`, voir [OpenRewrite](/docs/toolchain/jvm/rewrite) et
[Index du code des dépendances](/docs/toolchain/jvm/code-index). Le plugin de compilation n'ajoute pas de goals de réécriture
ou d'index de code, et ne transmet pas à ces commandes le graphe de dépendances résolu par Maven. Lisez
[la limite de la configuration du projet](/docs/build-tools#openrewrite-and-dependency-queries) avant de les utiliser à
côté de Maven.

## Limites

- kapt ne s'exécute pas : une exécution `kapt` avec des processeurs d'annotations configurés échoue.
- Les plugins du compilateur Kotlin (`<compilerPlugins>`) autres que all-open, no-arg, sam-with-receiver, assignment
  et Lombok échouent avec une erreur du compilateur.
- La `kotlin-stdlib` ajoutée est en version 2.3.21 ; déclarez vous-même `kotlin-stdlib` pour en choisir une autre.
- Chaque compilation lance un nouveau processus `elide` ; aucun démon de compilation n'est partagé entre les modules.

Pour quitter Maven, voir [Adopter un projet existant](/docs/toolchain/usage/adopt).
