Merge branch '2024.1' into 2024.2

# Conflicts:
#	build.gradle.kts
#	gradle.properties
#	gradle/libs.versions.toml
#	src/main/kotlin/creator/custom/ResourceBundleTranslator.kt

Author: RedNesto

build.gradle.kts

@@ -18,27 +18,20 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import org.cadixdev.gradle.licenser.header.HeaderStyle
-import org.cadixdev.gradle.licenser.tasks.LicenseUpdate
 import org.gradle.internal.jvm.Jvm
 import org.jetbrains.changelog.Changelog
+import org.jetbrains.gradle.ext.settings
+import org.jetbrains.gradle.ext.taskTriggers
 import org.jetbrains.intellij.platform.gradle.TestFrameworkType
 import org.jetbrains.intellij.platform.gradle.tasks.PrepareSandboxTask
-import org.jetbrains.intellij.platform.gradle.tasks.PublishPluginTask
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.jlleitschuh.gradle.ktlint.tasks.BaseKtLintCheckTask
-import org.jlleitschuh.gradle.ktlint.tasks.KtLintFormatTask
 
 plugins {
-    kotlin("jvm") version "1.9.24"
-    java
-    mcdev
     groovy
-    idea
-    id("org.jetbrains.intellij.platform") version "2.0.0"
-    id("org.cadixdev.licenser")
-    id("org.jlleitschuh.gradle.ktlint") version "10.3.0"
-    id("org.jetbrains.changelog") version "2.2.0"
+    id(libs.plugins.changelog.get().pluginId)
+    alias(libs.plugins.idea.ext)
+    `mcdev-core`
+    `mcdev-parsing`
+    `mcdev-publishing`
 }
 
 val ideaVersionProvider: Provider<String> = providers.gradleProperty("ideaVersion")
@@ -50,21 +43,9 @@ val testLibs: Configuration by configurations.creating {
     isTransitive = false
 }
 
-group = "com.demonwav.minecraft-dev"
+group = "com.demonwav.mcdev"
 version = "$ideaVersionName-$coreVersion"
 
-java {
-    toolchain {
-        languageVersion.set(JavaLanguageVersion.of(21))
-        vendor.set(JvmVendorSpec.JETBRAINS)
-    }
-}
-kotlin {
-    jvmToolchain {
-        languageVersion.set(java.toolchain.languageVersion.get())
-    }
-}
-
 val gradleToolingExtensionSourceSet: SourceSet = sourceSets.create("gradle-tooling-extension") {
     configurations.named(compileOnlyConfigurationName) {
         extendsFrom(gradleToolingExtension)
@@ -102,50 +83,42 @@ val externalAnnotationsJar = tasks.register<Jar>("externalAnnotationsJar") {
     archiveFileName.set("externalAnnotations.jar")
 }
 
-repositories {
-    maven("https://repo.denwav.dev/repository/maven-public/")
-    maven("https://maven.fabricmc.net/") {
-        content {
-            includeModule("net.fabricmc", "mapping-io")
-            includeModule("net.fabricmc", "fabric-loader")
-        }
-    }
-    mavenCentral()
-    maven("https://repo.spongepowered.org/maven/")
-
-    intellijPlatform {
-        defaultRepositories()
-    }
-}
-
 dependencies {
     // Add tools.jar for the JDI API
     implementation(files(Jvm.current().toolsJar))
 
+    implementation(files(gradleToolingExtensionJar))
+
     implementation(libs.mixinExtras.expressions)
     testLibs(libs.mixinExtras.common)
 
-    // Kotlin
-    implementation(kotlin("stdlib-jdk8"))
-    implementation(kotlin("reflect"))
-    implementation(libs.bundles.coroutines) {
-        exclude(module = "kotlinx-coroutines-core-jvm")
-    }
-
-    implementation(files(gradleToolingExtensionJar))
-
     implementation(libs.mappingIo)
     implementation(libs.bundles.asm)
 
     implementation(libs.bundles.fuel)
 
-    jflex(libs.jflex.lib)
-    jflexSkeleton(libs.jflex.skeleton) {
-        artifact {
-            extension = "skeleton"
-        }
+    intellijPlatform {
+        intellijIdeaCommunity(libs.versions.intellij.ide)
+
+        // Bundled plugin dependencies
+        bundledPlugin("com.intellij.java")
+        bundledPlugin("org.jetbrains.idea.maven")
+        bundledPlugin("com.intellij.gradle")
+        bundledPlugin("org.intellij.groovy")
+        bundledPlugin("ByteCodeViewer")
+        bundledPlugin("org.intellij.intelliLang")
+        bundledPlugin("com.intellij.properties")
+
+        // Optional dependencies
+        bundledPlugin("org.jetbrains.kotlin")
+        bundledPlugin("org.toml.lang")
+        bundledPlugin("org.jetbrains.plugins.yaml")
+
+        testFramework(TestFrameworkType.JUnit5)
+        testFramework(TestFrameworkType.Plugin.Java)
+
+        pluginVerifier()
     }
-    grammarKit(libs.grammarKit)
 
     intellijPlatform {
         intellijIdeaCommunity(ideaVersionProvider, useInstaller = false)
@@ -168,6 +141,8 @@ dependencies {
 
     testLibs(libs.test.mockJdk)
     testLibs(libs.test.mixin)
+    testLibs(libs.test.spigotapi)
+    testLibs(libs.test.bungeecord)
     testLibs(libs.test.spongeapi) {
         artifact {
             classifier = "shaded"
@@ -186,37 +161,6 @@ dependencies {
     gradleToolingExtension(libs.groovy)
     gradleToolingExtension(libs.gradleToolingExtension)
     gradleToolingExtension(libs.annotations)
-
-    testImplementation(libs.junit.api)
-    testRuntimeOnly(libs.junit.entine)
-    testRuntimeOnly(libs.junit.platform.launcher)
-}
-
-val artifactType = Attribute.of("artifactType", String::class.java)
-val filtered = Attribute.of("filtered", Boolean::class.javaObjectType)
-
-dependencies {
-    attributesSchema {
-        attribute(filtered)
-    }
-    artifactTypes.getByName("jar") {
-        attributes.attribute(filtered, false)
-    }
-
-    registerTransform(Filter::class) {
-        from.attribute(filtered, false).attribute(artifactType, "jar")
-        to.attribute(filtered, true).attribute(artifactType, "jar")
-
-        parameters {
-            ideaVersion.set(providers.gradleProperty("ideaVersion"))
-            ideaVersionName.set(providers.gradleProperty("ideaVersionName"))
-            depsFile.set(layout.projectDirectory.file(".gradle/intellij-deps.json"))
-        }
-    }
-}
-
-configurations.compileClasspath {
-    attributes.attribute(filtered, true)
 }
 
 changelog {
@@ -226,10 +170,7 @@ changelog {
 }
 
 intellijPlatform {
-    sandboxContainer.set(layout.projectDirectory.dir(".sandbox"))
-
-    instrumentCode = false
-    buildSearchableOptions = false
+    projectName = "Minecraft Development"
 
     pluginVerification {
         ides {
@@ -243,31 +184,6 @@ tasks.patchPluginXml {
     changeNotes = changelog.render(Changelog.OutputType.HTML)
 }
 
-tasks.withType<PublishPluginTask> {
-    // Build numbers are used for
-    properties["buildNumber"]?.let { buildNumber ->
-        project.version = "${project.version}-$buildNumber"
-    }
-    properties["mcdev.deploy.token"]?.let { deployToken ->
-        token.set(deployToken.toString())
-    }
-    channels.add(properties["mcdev.deploy.channel"]?.toString() ?: "Stable")
-}
-
-tasks.withType<JavaCompile>().configureEach {
-    options.encoding = "UTF-8"
-    options.compilerArgs = listOf("-proc:none")
-    options.release.set(21)
-}
-
-tasks.withType<KotlinCompile>().configureEach {
-    kotlinOptions {
-        jvmTarget = "21"
-        freeCompilerArgs = listOf("-Xjvm-default=all")
-        kotlinDaemonJvmArguments.add("-Xmx2G")
-    }
-}
-
 // Compile classes to be loaded into the Gradle VM to Java 5 to match Groovy
 // This is for maximum compatibility, these classes will be loaded into every Gradle import on all
 // projects (not just Minecraft), so we don't want to break that with an incompatible class version.
@@ -303,7 +219,6 @@ tasks.processResources {
 
 tasks.test {
     dependsOn(tasks.jar, testLibs)
-    useJUnitPlatform()
 
     testLibs.resolvedConfiguration.resolvedArtifacts.forEach {
         systemProperty("testLibs.${it.name}", it.file.absolutePath)
@@ -318,26 +233,22 @@ tasks.test {
 }
 
 idea {
-    module {
-        generatedSourceDirs.add(file("build/gen"))
-        excludeDirs.add(intellijPlatform.sandboxContainer.get().asFile)
-        isDownloadJavadoc = true
-        isDownloadSources = true
-    }
+    project.settings.taskTriggers.afterSync("generate")
 }
 
 license {
-    header.set(resources.text.fromFile(file("copyright.txt")))
-    style["flex"] = HeaderStyle.BLOCK_COMMENT.format
-    style["bnf"] = HeaderStyle.BLOCK_COMMENT.format
-
     val endings = listOf("java", "kt", "kts", "groovy", "gradle.kts", "xml", "properties", "html", "flex", "bnf")
     exclude("META-INF/plugin.xml") // https://youtrack.jetbrains.com/issue/IDEA-345026
     include(endings.map { "**/*.$it" })
 
-    exclude("com/demonwav/mcdev/platform/mixin/invalidInjectorMethodSignature/*.java")
+    val projectDir = layout.projectDirectory.asFile
+    exclude {
+        it.file.toRelativeString(projectDir)
+            .replace("\\", "/")
+            .startsWith("src/test/resources")
+    }
 
-    this.tasks {
+    tasks {
         register("gradle") {
             files.from(
                 fileTree(project.projectDir) {
@@ -354,6 +265,14 @@ license {
                 },
             )
         }
+        register("mixinTestData") {
+            files.from(
+                project.fileTree(project.projectDir.resolve("mixin-test-data")) {
+                    include("**/*.java", "**/*.kts")
+                    exclude("**/build/**")
+                },
+            )
+        }
         register("grammars") {
             files.from(project.fileTree("src/main/grammars"))
         }
@@ -363,19 +282,6 @@ license {
     }
 }
 
-ktlint {
-    disabledRules.add("filename")
-}
-tasks.withType<BaseKtLintCheckTask>().configureEach {
-    workerMaxHeapSize.set("512m")
-}
-
-tasks.register("format") {
-    group = "minecraft"
-    description = "Formats source code according to project style"
-    dependsOn(tasks.withType<LicenseUpdate>(), tasks.withType<KtLintFormatTask>())
-}
-
 val generateAtLexer by lexer("AtLexer", "com/demonwav/mcdev/platform/mcp/at/gen")
 val generateAtParser by parser("AtParser", "com/demonwav/mcdev/platform/mcp/at/gen")
 
@@ -420,12 +326,6 @@ sourceSets.main { java.srcDir(generate) }
 // Remove gen directory on clean
 tasks.clean { delete(generate) }
 
-tasks.register("cleanSandbox", Delete::class) {
-    group = "intellij"
-    description = "Deletes the sandbox directory."
-    delete(layout.projectDirectory.dir(".sandbox"))
-}
-
 tasks.withType<PrepareSandboxTask> {
     pluginJar.set(tasks.jar.get().archiveFile)
     from(externalAnnotationsJar) {

buildSrc/build.gradle.kts

@@ -18,16 +18,30 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
 plugins {
     `kotlin-dsl`
 }
 
+tasks.withType<JavaCompile>().configureEach {
+    options.release.set(8)
+}
+tasks.withType<KotlinCompile>().configureEach {
+    kotlinOptions.jvmTarget = "1.8"
+}
+
 repositories {
     mavenCentral()
     gradlePluginPortal()
 }
 
 dependencies {
-    implementation("com.google.code.gson:gson:2.9.1")
-    implementation("org.cadixdev.licenser:org.cadixdev.licenser.gradle.plugin:0.6.1")
+    // hack for version catalogs
+    implementation(files(libs.javaClass.superclass.protectionDomain.codeSource.location))
+    implementation(libs.gson)
+    implementation(libs.kotlin.plugin)
+    implementation(libs.intellij.plugin)
+    implementation(libs.licenser.plugin)
+    implementation(libs.changelog.plugin)
 }

buildSrc/settings.gradle.kts

@@ -19,3 +19,11 @@
  */
 
 rootProject.name = "buildSrc"
+
+dependencyResolutionManagement {
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}