Add support for gradle v9.

Author: vLuckyyy

build.gradle.kts

@@ -1,97 +1,132 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import java.io.FileOutputStream
 import java.io.IOException
 import java.util.jar.JarEntry
 import java.util.jar.JarFile
 import java.util.jar.JarOutputStream
 
-plugins{
+plugins {
     id("eternalcode.java")
     id("com.gradleup.shadow")
     id("xyz.jpenilla.run-paper") version "3.0.2"
 }
 
-tasks.create("shadowAll") {
-    group = "shadow"
+tasks.register<ShadowJar>("shadowChatFormatter") {
+    this.group = "build"
 
-    val projects = listOf(
+    val targetProjects = listOf(
         project(":chatformatter-core"),
         project(":chatformatter-paper-plugin")
     )
 
-    for (project in projects) {
-        dependsOn(project.name + ":shadowJar")
+    for (targetProject in targetProjects) {
+        this.dependsOn("${targetProject.name}:shadowJar")
     }
 
-    doLast {
-        merge("ChatFormatter v${project.version}.jar", projects)
+    this.doLast {
+        this@register.mergeJars(
+            "ChatFormatter v${project.version}.jar",
+            targetProjects
+        )
     }
 }
 
-fun merge(archiveFileName: String, projects: List<Project>) {
-    val outputFile = File(project.layout.buildDirectory.asFile.get(), "libs/${archiveFileName}")
-    val outputDir = outputFile.parentFile ?: throw RuntimeException("Could not get output directory")
+fun ShadowJar.mergeJars(archiveFileName: String, projects: List<Project>) {
+    val outputFile = File(
+        this.project.layout.buildDirectory.asFile.get(),
+        "libs/$archiveFileName"
+    )
+    val outputDir = outputFile.parentFile
+        ?: throw IllegalStateException("Kurwa, nie mogę znaleźć katalogu wyjściowego")
 
     if (!outputDir.exists() && !outputDir.mkdirs()) {
-        throw RuntimeException("Could not create output directory")
+        throw IllegalStateException("Nie udało się stworzyć katalogu: ${outputDir.absolutePath}")
     }
 
-    if (outputFile.exists()) {
-        outputFile.delete()
+    if (outputFile.exists() && !outputFile.delete()) {
+        throw IllegalStateException("Nie można usunąć istniejącego pliku: ${outputFile.absolutePath}")
     }
 
     if (!outputFile.createNewFile()) {
-        throw RuntimeException("Could not find output file to merge")
+        throw IllegalStateException("Nie można utworzyć pliku wyjściowego: ${outputFile.absolutePath}")
     }
 
+    mergeShadowJarsIntoOutput(outputFile, projects)
+}
+
+private fun mergeShadowJarsIntoOutput(
+    outputFile: File,
+    projects: List<Project>
+) {
     JarOutputStream(FileOutputStream(outputFile)).use { outputJar ->
-        for (project in projects) {
-            val shadowJar = project.tasks.shadowJar.get()
-
-            for (file in shadowJar.outputs.files.files) {
-                JarFile(file).use { jarFile ->
-                    for (entry in jarFile.entries()) {
-                        if (entry.isDirectory) {
-                            continue
-                        }
-
-                        val bytes = jarFile.getInputStream(entry).readBytes()
-                        val newEntry = JarEntry(entry.name)
-
-                        newEntry.setTime(System.currentTimeMillis())
-                        newEntry.setSize(bytes.size.toLong())
-
-                        try {
-                            outputJar.putNextEntry(newEntry)
-                            outputJar.write(bytes)
-                            outputJar.closeEntry()
-                        }
-                        catch (exception: IOException) {
-                            if (exception.message?.contains("duplicate entry: ") == true) {
-                                continue
-                            }
-
-                            exception.printStackTrace()
-                        }
-                    }
+        val processedEntries = mutableSetOf<String>()
+
+        for (targetProject in projects) {
+            val shadowJarTask = targetProject.tasks.named("shadowJar", ShadowJar::class.java).get()
+
+            for (jarFile in shadowJarTask.outputs.files.files) {
+                processJarFile(jarFile, outputJar, processedEntries)
+            }
+        }
+    }
+}
+
+private fun processJarFile(
+    jarFile: File,
+    outputJar: JarOutputStream,
+    processedEntries: MutableSet<String>
+) {
+    JarFile(jarFile).use { sourceJar ->
+        for (entry in sourceJar.entries()) {
+            if (entry.isDirectory || processedEntries.contains(entry.name)) {
+                continue
+            }
+
+            try {
+                copyJarEntry(sourceJar, entry, outputJar)
+                processedEntries.add(entry.name)
+            } catch (exception: IOException) {
+                if (exception.message?.contains("duplicate entry:") != true) {
+                    throw exception
                 }
             }
         }
     }
+}
 
+private fun copyJarEntry(
+    sourceJar: JarFile,
+    entry: JarEntry,
+    outputJar: JarOutputStream
+) {
+    val entryBytes = sourceJar.getInputStream(entry).use { it.readBytes() }
+    val newEntry = JarEntry(entry.name).apply {
+        this.time = System.currentTimeMillis()
+        this.size = entryBytes.size.toLong()
+    }
+
+    outputJar.putNextEntry(newEntry)
+    outputJar.write(entryBytes)
+    outputJar.closeEntry()
 }
 
 runPaper {
-    disablePluginJarDetection()
+    this.disablePluginJarDetection()
 }
 
 tasks.runServer {
-    minecraftVersion("1.21.9")
-    dependsOn("shadowAll")
-    pluginJars = files("/build/libs/ChatFormatter v${project.version}.jar")
-    // We need to start the server with Java 21, but jar is built with Java 17
-    javaLauncher.set(javaToolchains.launcherFor {
-        languageVersion.set(JavaLanguageVersion.of(21))
-    })
-    downloadPlugins.modrinth("luckperms", "v5.5.0-bukkit")
-    downloadPlugins.modrinth("VaultUnlocked", "2.16.0")
-}
+    minecraftVersion("1.21.10")
+    dependsOn("shadowChatFormatter")
+    pluginJars.from(layout.buildDirectory.file("libs/ChatFormatter v${project.version}.jar"))
+
+    javaLauncher.set(
+        javaToolchains.launcherFor {
+            this.languageVersion.set(JavaLanguageVersion.of(21))
+        }
+    )
+
+    downloadPlugins {
+        this.modrinth("luckperms", "v5.5.0-bukkit")
+        this.modrinth("VaultUnlocked", "2.16.0")
+    }
+}