Load addons as plugins

Author: NichtStudioCode

gradle/libs.versions.toml

@@ -2,6 +2,7 @@
 format.version = "1.1"
 
 [versions]
+bytebase = "0.4.8"
 cbf = "0.15"
 invui = "1.37"
 jgrapht = "1.5.2"
@@ -15,13 +16,15 @@ xenondevs-commons = "1.18"
 [libraries]
 awssdk-s3 = { group = "software.amazon.awssdk", name = "s3", version = "2.28.21" }
 bstats = { group = "xyz.xenondevs.bstats", name = "bstats-bukkit", version = "3.0.1" }
-bytbase-runtime = { group = "xyz.xenondevs.bytebase", name = "ByteBase-Runtime", version = "0.4.8" }
+bytebase = { group = "xyz.xenondevs.bytebase", name = "ByteBase", version.ref = "bytebase" }
+bytebase-runtime = { group = "xyz.xenondevs.bytebase", name = "ByteBase-Runtime", version.ref = "bytebase" }
 caffeine = { group = "com.github.ben-manes.caffeine", name = "caffeine", version = "3.1.8" }
 commons-collections = { group = "xyz.xenondevs.commons", name = "commons-collections", version.ref = "xenondevs-commons" }
 commons-gson = { group = "xyz.xenondevs.commons", name = "commons-gson", version.ref = "xenondevs-commons" }
 commons-guava = { group = "xyz.xenondevs.commons", name = "commons-guava", version.ref = "xenondevs-commons" }
 commons-provider = { group = "xyz.xenondevs.commons", name = "commons-provider", version.ref = "xenondevs-commons" }
 commons-reflection = { group = "xyz.xenondevs.commons", name = "commons-reflection", version.ref = "xenondevs-commons" }
+configurate-yaml = { group = "org.spongepowered", name = "configurate-yaml", version = "4.1.2" }
 cosmic-binary-format = { group = "xyz.xenondevs.cbf", name = "cosmic-binary-format", version.ref = "cbf" }
 fuzzywuzzy = { group = "me.xdrop", name = "fuzzywuzzy", version = "1.4.0" }
 gson = { group = "com.google.code.gson", name = "gson", version = "2.11.0" }
@@ -44,9 +47,6 @@ ktor-serialization-gson-jvm = { group = "io.ktor", name = "ktor-serialization-gs
 ktor-server-cio-jvm = { group = "io.ktor", name = "ktor-server-cio-jvm", version.ref = "ktor" }
 ktor-server-core-jvm = { group = "io.ktor", name = "ktor-server-core-jvm", version.ref = "ktor" }
 lz4 = { group = "org.lz4", name = "lz4-java", version = "1.8.0" }
-maven-resolver-connector-basic = { group = "org.apache.maven.resolver", name = "maven-resolver-connector-basic", version = "1.9.18" }
-maven-resolver-provider = { group = "org.apache.maven", name = "maven-resolver-provider", version = "3.9.9" }
-maven-resolver-transport-http = { group = "org.apache.maven.resolver", name = "maven-resolver-transport-http", version = "1.9.22" }
 minecraft-asset-downloader = { group = "xyz.xenondevs", name = "minecraft-asset-downloader", version = "1.3" }
 minecraft-model-renderer = { group = "xyz.xenondevs", name = "minecraft-model-renderer", version = "1.3" }
 paper-api = { group = "io.papermc.paper", name = "paper-api", version.ref = "paper" }
@@ -58,7 +58,6 @@ cbf = ["cosmic-binary-format"]
 jgrapht = ["jgrapht-core", "jgrapht-io"]
 kotlin = ["kotlin-stdlib", "kotlin-reflect", "kotlinx-coroutines-core-jvm", "kotlinx-coroutines-debug"]
 ktor = ["ktor-server-core-jvm", "ktor-server-cio-jvm", "ktor-client-core-jvm", "ktor-client-cio-jvm", "ktor-client-content-negotiation", "ktor-serialization-gson-jvm"]
-maven-resolver = ["maven-resolver-provider", "maven-resolver-connector-basic", "maven-resolver-transport-http"]
 minecraft-assets = ["minecraft-asset-downloader", "minecraft-model-renderer"]
 test = ["kotlin-test-junit", "junit-jupiter"]
 xenondevs-commons = ["commons-collections", "commons-gson", "commons-guava", "commons-provider", "commons-reflection"]

nova-gradle-plugin/build.gradle.kts

@@ -6,16 +6,19 @@ plugins {
 }
 
 dependencies {
-    implementation(libs.gson)
+    compileOnly(project(":nova"))
     implementation(libs.bundles.xenondevs.commons)
     implementation(libs.bundles.minecraft.assets)
+    implementation(libs.configurate.yaml)
+    implementation(libs.bytebase)
+    compileOnly(libs.paper.api)
 }
 
 gradlePlugin {
     plugins {
         create("nova-gradle-plugin") {
             id = "xyz.xenondevs.nova.nova-gradle-plugin"
-            description = "Nova gradle plugin to assist with addon development"
+            description = "Gradle plugin for creating Nova addons"
             implementationClass = "xyz.xenondevs.novagradle.NovaGradlePlugin"
         }
     }

nova-gradle-plugin/src/main/kotlin/xyz/xenondevs/novagradle/NovaGradlePlugin.kt

@@ -6,45 +6,64 @@ import org.gradle.jvm.tasks.Jar
 import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.getByName
 import org.gradle.kotlin.dsl.register
-import xyz.xenondevs.novagradle.task.AddonMetadataExtension
-import xyz.xenondevs.novagradle.task.AddonMetadataTask
+import xyz.xenondevs.novagradle.task.AddonExtension
+import xyz.xenondevs.novagradle.task.AddonJarTask
 import xyz.xenondevs.novagradle.task.GenerateLanguageFilesTask
 import xyz.xenondevs.novagradle.task.GenerateWailaTexturesExtension
 import xyz.xenondevs.novagradle.task.GenerateWailaTexturesTask
-import xyz.xenondevs.novagradle.util.AddonUtils
+import xyz.xenondevs.novagradle.task.PluginDependency
+import xyz.xenondevs.novagradle.task.PluginDependency.Load
+import xyz.xenondevs.novagradle.task.PluginDependency.Stage
+import xyz.xenondevs.novagradle.util.TaskUtils
 
 class NovaGradlePlugin : Plugin<Project> {
 
     override fun apply(project: Project) {
-        val addonExt = project.extensions.create<AddonMetadataExtension>("addon")
-        val addonMetadataTask = project.tasks.register<AddonMetadataTask>("addonMetadata")
-        val jarTask = addonExt.jarTask.orElse(project.tasks.getByName<Jar>("jar"))
-        addonMetadataTask.configure {
-            this.id.set(addonExt.id)
+        val libraryLoaderCfg = project.configurations.create("libraryLoader")
+        project.configurations.getByName("implementation").extendsFrom(libraryLoaderCfg)
+        
+        val addonExt = project.extensions.create<AddonExtension>("addon")
+        val addonJarTask = project.tasks.register<AddonJarTask>("addonJar") {
+            group = "build"
+            dependsOn("jar")
+        }
+        addonJarTask.configure {
             this.addonName.set(addonExt.name)
-            this.version.set(addonExt.version)
-            this.novaVersion.set(addonExt.novaVersion)
             this.main.set(addonExt.main)
+            this.loader.set(addonExt.loader)
+            this.bootstrapper.set(addonExt.bootstrapper)
+            this.version.set(addonExt.version)
+            this.dependencies.set(addonExt.dependencies)
+            this.dependencies.add(PluginDependency("Nova", Stage.BOOTSTRAP, Load.BEFORE, true, true))
+            this.dependencies.add(PluginDependency("Nova", Stage.SERVER, Load.BEFORE, true, true))
+            this.addonDescription.set(addonExt.description)
             this.authors.set(addonExt.authors)
-            this.depend.set(addonExt.depend)
-            this.softdepend.set(addonExt.softdepend)
-            this.jarTask.set(jarTask)
+            this.contributors.set(addonExt.contributors)
+            this.website.set(addonExt.website)
+            this.prefix.set(addonExt.prefix)
+            
+            this.input.set(TaskUtils.getOutputFile(project.tasks.getByName<Jar>("jar")))
+            this.output.set(
+                addonExt.destination
+                    .orElse(project.layout.buildDirectory.dir("libs/"))
+                    .map {
+                        val name = addonExt.name.getOrElse(project.name)
+                        val version = addonExt.version.getOrElse(project.version.toString())
+                        it.file("$name-$version.jar") 
+                    }
+            )
         }
-        jarTask.get().finalizedBy(addonMetadataTask)
 
         val wailaExt = project.extensions.create<GenerateWailaTexturesExtension>("generateWailaTextures")
         val wailaTask = project.tasks.register<GenerateWailaTexturesTask>("generateWailaTextures")
         wailaTask.configure {
-            novaVersion.set(wailaExt.novaVersion.orElse(addonExt.novaVersion))
-            resourcesDir.set(wailaExt.resourcesDir.orElse("src/main/resources/"))
-            addonId.set(wailaExt.addonId.orElse(addonExt.id).orElse(resourcesDir.map { AddonUtils.getAddonId(project, it) }))
-            filter.set(wailaExt.filter.orElse { true })
+            this.resourcesDir.set(wailaExt.resourcesDir.orElse("src/main/resources/"))
+            this.addonId.set(addonExt.name.map { it.lowercase() })
+            this.filter.set(wailaExt.filter.orElse { true })
         }
 
         project.tasks.register<GenerateLanguageFilesTask>("generateLanguageFiles")
-        
-        val novaCfg = project.configurations.create("nova")
-        project.configurations.getByName("implementation").extendsFrom(novaCfg)
     }
 
+    
 }

nova-gradle-plugin/src/main/kotlin/xyz/xenondevs/novagradle/task/AddonExtension.kt

@@ -0,0 +1,76 @@
+package xyz.xenondevs.novagradle.task
+
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import xyz.xenondevs.novagradle.task.PluginDependency.Load
+import xyz.xenondevs.novagradle.task.PluginDependency.Stage
+import java.io.Serializable
+
+abstract class AddonExtension {
+    
+    abstract val name: Property<String>
+    abstract val version: Property<String>
+    abstract val main: Property<String>
+    abstract val bootstrapper: Property<String>
+    abstract val loader: Property<String>
+    abstract val dependencies: ListProperty<PluginDependency>
+    abstract val description: Property<String>
+    abstract val authors: ListProperty<String>
+    abstract val contributors: ListProperty<String>
+    abstract val website: Property<String>
+    abstract val prefix: Property<String>
+    abstract val destination: DirectoryProperty
+    
+    /**
+     * Creates a dependency on a plugin named [name] in both the [Stage.BOOTSTRAP] and [Stage.SERVER] stages.
+     * The load order is defined by [load], the plugin will require the dependency if [required] is true, and the plugin's
+     * classes will be accessible if [joinClasspath] is true.
+     */
+    fun dependency(name: String, load: Load = Load.OMIT, required: Boolean = true, joinClasspath: Boolean = true) {
+        dependency(name, Stage.BOOTSTRAP, load, required, joinClasspath)
+        dependency(name, Stage.SERVER, load, required, joinClasspath)
+    }
+    
+    /**
+     * Creates a dependency on a plugin named [name] in the specified [stage].
+     * The load order is defined by [load], the plugin will require the dependency if [required] is true, and the plugin's
+     * classes will be accessible if [joinClasspath] is true.
+     */
+    fun dependency(name: String, stage: Stage, load: Load = Load.OMIT, required: Boolean = true, joinClasspath: Boolean = true) {
+        dependencies.add(PluginDependency(name, stage, load, required, joinClasspath))
+    }
+    
+}
+
+data class PluginDependency(val name: String, val stage: Stage, val load: Load, val required: Boolean, val joinClasspath: Boolean) : Serializable {
+    
+    /**
+     * The stage in which the dependency exists.
+     */
+    enum class Stage {
+        BOOTSTRAP, SERVER
+    }
+    
+    /**
+     * Defines the load order of the dependency and your plugin.
+     */
+    enum class Load {
+        
+        /**
+         * The dependency will be loaded before your plugin.
+         */
+        BEFORE,
+        
+        /**
+         * The dependency will be loaded after your plugin.
+         */
+        AFTER,
+        
+        /**
+         * The load order is unspecified.
+         */
+        OMIT
+    }
+    
+}