Version Gradle du template Java 25

Author: grumpyf0x48

Makefile

@@ -12,6 +12,9 @@ run-app: ## Lancer l'application localement
 run-installed-app: .check-install-dir ## Lancer l'application installée
 	PATH=$(DEST_DIR)/$(APP_DIR)/bin:$(PATH) $(APP_NAME).sh --language French
 
+test: ## Exécuter les tests
+	./gradlew test
+
 clean: ## Nettoyer le répertoire de construction
 	rm --force --recursive $(BUILD)
 

README.md

@@ -1,19 +1,43 @@
-# Un template d'Application en Ligne de Commande (CLI) avec Java 23 et les JEP 458 et 477
+# Un template d'Application en Ligne de Commande (CLI) avec Java 25 et les JEP 458, 511 et 512
 
-Le template **java-23-quickstart** permet de démarrer une nouvelle application en commande ligne avec Java et Gradle.
+Le template **java-25-quickstart** permet de démarrer une nouvelle application en commande ligne avec Java et Gradle.
 
-Ce template nécessite d'utiliser Java 23 ou une version supérieure car il utilise les JEPs suivantes :
+Ce template utilise les JEPs suivantes :
 
-* La [JEP 458](https://openjdk.org/jeps/458) qui permet de lancer un programme Java dont le code est réparti dans
-  plusieurs fichiers sources sans avoir besoin de les compiler préalablement
-* La [JEP 477](https://openjdk.org/jeps/477) qui permet de :
-  * Se passer de déclaration de classe
-  * Simplifier la déclaration de la méthode `main`
-  * Utiliser les méthodes de la classe `java.io.IO` sans devoir les importer
+* La [JEP 458: Launch Multi-File Source-Code Programs](https://openjdk.org/jeps/458) qui permet de lancer un programme
+  Java dont le code est réparti dans plusieurs fichiers sources sans avoir besoin de les compiler préalablement
+* La [JEP 511: Module Import Declarations](https://openjdk.org/jeps/511) qui permet d'importer tous les packages
+  exportés par un module java
+* La [JEP 512: Compact Source Files and Instance Main Methods](https://openjdk.org/jeps/512) qui permet de :
+    * Se passer de déclaration de classe
+    * Simplifier la déclaration de la méthode `main`
+    * Utiliser les méthodes `println` et `readln` de la classe `java.lang.IO`
+
+Le template utilise la librairie [record-args](https://github.com/nipafx/record-args), développée par
+[Nicolai Parlog](https://nipafx.dev), et qui s'appuie sur les `record` et les interfaces `sealed` pour définir les
+arguments de la ligne de commande et en effectuer le parsing.
+
+* [Créer une application depuis ce template](#créer-une-application-depuis-ce-template)
+* [Construire votre application](#construire-votre-application)
+    * [Changer le nom de l'application](#changer-le-nom-de-lapplication)
+    * [Lancer l'application localement](#lancer-lapplication-localement)
+    * [Afficher l'aide de l'application](#afficher-laide-de-lapplication)
+    * [Construire le livrable de l'application](#construire-le-livrable-de-lapplication)
+* [Installer l'application](#installer-lapplication)
+    * [Shell de lancement](#shell-de-lancement)
+    * [Lancer l'application installée](#lancer-lapplication-installée)
+* [Exécuter les tests](#exécuter-les-tests)
+* [Autres templates](#autres-templates)
+
+## Créer une application depuis ce template
+
+Pour créer une application depuis ce template, on procédera comme suit :
+
+<a href="https://asciinema.org/a/732396" target="_blank"><img src="https://asciinema.org/a/732396.svg" /></a>
 
 ## Construire votre application
 
-Après avoir [créé le dépôt GitHub](https://github.com/new?template_name=java-23-quickstart&template_owner=java-cli-apps)
+Après avoir [créé le dépôt GitHub](https://github.com/new?template_name=java-25-quickstart&template_owner=java-cli-apps)
 de votre nouvelle application à partir de ce template, vous pouvez suivre les étapes suivantes pour construire votre application.
 
 ### Changer le nom de l'application
@@ -72,7 +96,7 @@ $ DEST_DIR=/home/user make run-installed-app
 ```
 
 ```console
-PATH=/home/user/QuickStart/bin:/usr/lib/jvm/jdk-23/bin:/home/fopy/.local/bin:... QuickStart.sh --language French
+PATH=/home/user/QuickStart/bin:/usr/lib/jvm/jdk-25/bin:/home/fopy/.local/bin:... QuickStart.sh --language French
 Bonjour 🇫🇷
 ```
 
@@ -81,16 +105,35 @@ Il ne nous reste plus qu'à :
 - Implémenter notre métier dans [Application.java](src/main/java/Application.java)
 - Ajouter dans le répertoire [src/main/java](src/main/java) les fichiers qui déclarent les classes utilisées par `Application.java`
 - Ajouter les caractéristiques de nos dépendances dans [gradle/libs.versions.toml](gradle/libs.versions.toml) et [build.gradle.kts](build.gradle.kts)
+- Implémenter des tests
+
+
+## Exécuter les tests
+
+Dans ce template utilisant Gradle, les tests utilisent JUnit, et contrairement
+au template [basic-java-25-quickstart](https://github.com/java-cli-apps/basic-java-25-quickstart)
+ils n'utilisent pas la JEP 458: les sources sont compilées avant les tests.
+
+```bash
+$ make test
+```
 
 ## Autres templates
 
-### Sans utiliser Java 23
+### Sans utiliser Java 25
+
+Si vous ne disposez pas de Java 25, vous avez trois possibilités :
 
-Si vous ne disposez pas de Java 23, vous pouvez utiliser le template [basic-java-11-quickstart](https://github.com/java-cli-apps/basic-java-11-quickstart)
-qui ne requiert que la version 11 de Java. Il est alors nécessaire que tout le code Java réside dans le même fichier
-comme décrit dans la [JEP 330](https://openjdk.org/jeps/330).
+- Utiliser les templates [java-23-quickstart](https://github.com/java-cli-apps/java-23-quickstart) ou
+  [java-22-quickstart](https://github.com/java-cli-apps/java-22-quickstart) qui ne nécessitent
+  respectivement que la version 23 ou 22 de Java.
+- Utiliser le template [basic-java-11-quickstart](https://github.com/java-cli-apps/basic-java-11-quickstart)
+  qui ne requiert que la version 11 de Java. Il est alors nécessaire que tout le code Java réside dans le même fichier
+  comme décrit dans la [JEP 330](https://openjdk.org/jeps/330).
 
 ### Sans utiliser Gradle
 
-Si vous ne disposez pas de Gradle ou que vous ne souhaitez pas l'utiliser, vous pouvez utiliser le template [basic-java-23-quickstart](https://github.com/java-cli-apps/basic-java-23-quickstart)
-qui ne requiert que `make` pour construire l'application.
+Si vous ne disposez pas de Gradle ou que vous ne souhaitez pas l'utiliser, vous
+pouvez utiliser les templates [basic-java-25-quickstart](https://github.com/java-cli-apps/basic-java-25-quickstart)
+ou [basic-java-23-quickstart](https://github.com/java-cli-apps/basic-java-23-quickstart)
+qui ne requierent que `make` pour construire l'application.

build.gradle.kts

@@ -11,12 +11,12 @@ application {
 
 java {
     toolchain {
-        languageVersion.set(JavaLanguageVersion.of(23))
+        languageVersion.set(JavaLanguageVersion.of(25))
     }
 }
 
 dependencies {
-    implementation(libs.picocli)
+    implementation(libs.record.args)
     testImplementation(libs.junit.jupiter)
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
@@ -45,14 +45,6 @@ tasks.named<Zip>("scriptsDistZip") {
     archiveFileName.set("${APP_NAME}.zip")
 }
 
-tasks.compileJava {
-    options.compilerArgs.addAll(listOf("--enable-preview"))
-}
-
-tasks.withType<JavaExec> {
-    jvmArgs = listOf("--enable-preview")
-}
-
 tasks.named<Test>("test") {
     useJUnitPlatform()
 }

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
+record-args = "0.9.3"
 junit-jupiter = "5.13.4"
-picocli = "4.7.7"
 
 [libraries]
+record-args = { module = "dev.nipafx.args:record-args", version.ref = "record-args" }
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
-picocli = { module = "info.picocli:picocli", version.ref = "picocli" }

src/main/java/Application.java

@@ -1,24 +1,26 @@
-//usr/bin/env java --enable-preview --class-path ${APP_DIR:-.}/lib/'*' "$0" "$@"; exit $?
+//usr/bin/env java --class-path ${APP_DIR:-.}/lib/'*' "$0" "$@"; exit $?
 
-import language.api.Greeting;
-import language.api.Greeting.Language;
+import dev.nipafx.args.Args;
 
-import picocli.CommandLine;
-import picocli.CommandLine.Command;
-import picocli.CommandLine.Option;
+import static java.lang.IO.println;
 
 void main(String... args) {
-    var method = CommandLine.getCommandMethods(getClass(), null).getFirst();
-    var commandLine = new CommandLine(method);
-    int exitCode = commandLine.execute(args);
-    System.exit(exitCode);
+    try {
+        sayHello(Args.parse(args, ParsedArgs.class));
+    } catch (Exception exception) {
+        printHelp();
+        throw new RuntimeException(exception);
+    }
 }
 
-@Command(name = "PolyglotHello", mixinStandardHelpOptions = true)
-private int polyglotHello(
-        @Option(names = {"-l", "--language"}, required = true, description = "Valid values are: ${COMPLETION-CANDIDATES}")
-        Language language
-) {
-    println(Greeting.byLanguage(language).getGreeting());
-    return CommandLine.ExitCode.OK;
+void sayHello(ParsedArgs parsedArgs) {
+    if (parsedArgs.hasHelpFlag()) {
+        printHelp();
+    } else {
+        println(parsedArgs.getLanguage().getGreeting());
+    }
+}
+
+void printHelp() {
+    println("Usage: Application [--language %s | %s] [--help]".formatted(Language.French, Language.English));
 }

src/main/java/Language.java

@@ -0,0 +1,30 @@
+import module java.base;
+
+enum Language {
+
+    French("Bonjour", new int[]{0x1F1EB, 0x1F1F7}),
+    English("Hello", new int[]{0x1F1EC, 0x1F1E7});
+
+    private final String message;
+    private final int[] emoji;
+
+    Language(String message, int[] emoji) {
+        this.message = message;
+        this.emoji = emoji;
+    }
+
+    String getGreeting() {
+        return "%s %s%s".formatted(message, Character.toString(emoji[0]), Character.toString(emoji[1]));
+    }
+
+    static Optional<Language> fromString(String language) {
+        return Arrays.stream(values())
+                .filter(current_language -> current_language.name().equalsIgnoreCase(language))
+                .findFirst();
+    }
+
+    static void validate(String language) {
+        fromString(language)
+                .orElseThrow(() -> new IllegalArgumentException("Unknown language provided: %s".formatted(language)));
+    }
+}

src/main/java/ParsedArgs.java

@@ -0,0 +1,18 @@
+import module java.base;
+
+record ParsedArgs(Optional<String> language, Optional<Boolean> help) {
+
+    ParsedArgs {
+        language.ifPresent(Language::validate);
+    }
+
+    boolean hasHelpFlag() {
+        return help.orElse(false);
+    }
+
+    Language getLanguage() {
+        return language
+                .flatMap(Language::fromString)
+                .orElse(Language.French);
+    }
+}