Use jpenilla/resource-factory to generate plugin.yml file

README.md

@@ -21,7 +21,6 @@ Gradle utilities to simplify Bukkit/Spigot plugins writing and debugging.
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
 #### Features:
-- Automatically applies plugin: java
 - Sets up compiler encoding to UTF-8
 - Sets archivesBaseName to plugin name
 - Supports APIs: Bukkit, CraftBukkit, Spigot, Paper

build.gradle.kts

@@ -29,7 +29,7 @@ repositories {
 
 dependencies {
     implementation("xyz.jpenilla.run-paper:xyz.jpenilla.run-paper.gradle.plugin:2.3.1")
-    implementation("de.undercouch:gradle-download-task:5.6.0")
+    implementation("xyz.jpenilla.resource-factory:xyz.jpenilla.resource-factory.gradle.plugin:1.2.0")
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.8.1")
     implementation("com.charleskorn.kaml:kaml:0.74.0")
     testImplementation("junit:junit:4.13.1")

src/main/kotlin/Bukkit.kt

@@ -1,16 +1,14 @@
 package ru.endlesscode.bukkitgradle
 
 import org.gradle.api.provider.Provider
-import ru.endlesscode.bukkitgradle.plugin.extension.PluginConfiguration
+import ru.endlesscode.bukkitgradle.plugin.plugin
 import ru.endlesscode.bukkitgradle.server.extension.ServerConfiguration
+import xyz.jpenilla.resourcefactory.bukkit.BukkitPluginYaml
 
 public interface Bukkit {
 
-    /** Plugin plugin. */
-    public val plugin: PluginConfiguration
-
     @Deprecated("Use 'plugin' field instead", ReplaceWith("plugin"))
-    public val meta: PluginConfiguration
+    public val meta: BukkitPluginYaml
         get() = plugin
 
     /** Dev server configuration. */
@@ -20,7 +18,10 @@ public interface Bukkit {
     public val apiVersion: Provider<String>
 
     /** Plugin Meta generation enabled. */
-    @Deprecated("Use 'plugin.generatePluginYaml' instead", ReplaceWith("plugin.generatePluginYaml"))
+    @Deprecated("Use 'generatePluginYaml' instead", ReplaceWith("generatePluginYaml"))
     public val generateMeta: Provider<Boolean>
-        get() = plugin.generatePluginYaml
+        get() = generatePluginYaml
+
+    /** Whether plugin.yml generation enabled or not. */
+    public val generatePluginYaml: Provider<Boolean>
 }

src/main/kotlin/BukkitExtension.kt

@@ -7,16 +7,20 @@ import org.gradle.api.provider.Property
 import org.gradle.kotlin.dsl.getByType
 import org.gradle.kotlin.dsl.property
 import ru.endlesscode.bukkitgradle.extensions.finalizedOnRead
-import ru.endlesscode.bukkitgradle.plugin.extension.PluginConfigurationImpl
+import ru.endlesscode.bukkitgradle.plugin.plugin
 import ru.endlesscode.bukkitgradle.server.ServerConstants
 import ru.endlesscode.bukkitgradle.server.extension.ServerConfigurationImpl
+import xyz.jpenilla.resourcefactory.bukkit.BukkitPluginYaml
 
 public open class BukkitExtension internal constructor(
-    public final override val plugin: PluginConfigurationImpl,
     public final override val server: ServerConfigurationImpl,
     objects: ObjectFactory,
 ) : Bukkit {
 
+    override val generatePluginYaml: Property<Boolean> = objects.property<Boolean>()
+        .convention(true)
+        .finalizedOnRead()
+
     public final override val apiVersion: Property<String> = objects.property<String>()
         .convention(ServerConstants.DEFAULT_VERSION)
         .finalizedOnRead()
@@ -25,22 +29,22 @@ public open class BukkitExtension internal constructor(
         body.execute(server)
     }
 
-    public fun plugin(body: Action<PluginConfigurationImpl>) {
-        body.execute(plugin)
-    }
-
     @Deprecated("Use 'plugin' instead", ReplaceWith("plugin(body)"))
-    public fun meta(body: Action<PluginConfigurationImpl>) {
-        plugin(body)
+    public fun meta(body: Action<BukkitPluginYaml>) {
+        plugin { body.execute(this) }
     }
 
     /** Disables plugin.yml generation. */
     @Deprecated(
-        "Use 'plugin.disablePluginYamlGeneration()' instead",
-        ReplaceWith("plugin.disablePluginYamlGeneration()")
+        "Use 'generatePluginYaml.set(false)' instead",
+        ReplaceWith("generatePluginYaml.set(false)")
     )
     public fun disableMetaGeneration() {
-        plugin.disablePluginYamlGeneration()
+        generatePluginYaml.set(false)
+    }
+
+    public companion object {
+        public const val NAME: String = "bukkit"
     }
 }
 

src/main/kotlin/BukkitGradlePlugin.kt

@@ -2,14 +2,15 @@ package ru.endlesscode.bukkitgradle
 
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.tasks.compile.JavaCompile
-import org.gradle.kotlin.dsl.*
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.create
+import org.gradle.kotlin.dsl.repositories
+import org.gradle.kotlin.dsl.withType
 import ru.endlesscode.bukkitgradle.dependencies.Dependencies
-import ru.endlesscode.bukkitgradle.plugin.PluginConfigurationPlugin
-import ru.endlesscode.bukkitgradle.plugin.extension.PluginConfigurationImpl
-import ru.endlesscode.bukkitgradle.plugin.util.MinecraftVersion
-import ru.endlesscode.bukkitgradle.plugin.util.StringUtils
+import ru.endlesscode.bukkitgradle.extensions.java
+import ru.endlesscode.bukkitgradle.plugin.configurePluginYamlFeature
 import ru.endlesscode.bukkitgradle.plugin.util.parsedApiVersion
 import ru.endlesscode.bukkitgradle.plugin.util.resolveMinimalJavaVersion
 import ru.endlesscode.bukkitgradle.server.DevServerPlugin
@@ -30,32 +31,21 @@ public class BukkitGradlePlugin : Plugin<Project> {
 
     /** Adds needed plugins. */
     private fun Project.addPlugins() {
-        val bukkit = extensions.create<BukkitExtension>("bukkit", createPluginConfiguration(), ServerConfigurationImpl())
+        val bukkit = extensions.create<BukkitExtension>(
+            BukkitExtension.NAME,
+            ServerConfigurationImpl(),
+        )
 
-        with(plugins) {
-            apply("java")
-            apply<PluginConfigurationPlugin>()
-            apply<DevServerPlugin>()
-        }
+        configurePluginYamlFeature(bukkit)
+        apply<DevServerPlugin>()
 
-        extensions.configure<JavaPluginExtension> {
-            toolchain {
+        plugins.withType<JavaBasePlugin> {
+            java.toolchain {
                 languageVersion.convention(bukkit.parsedApiVersion.map(::resolveMinimalJavaVersion))
             }
         }
     }
 
-    private fun Project.createPluginConfiguration(): PluginConfigurationImpl {
-        return PluginConfigurationImpl(objects).apply {
-            name.convention(project.name)
-            description.convention(provider { project.description })
-            main.convention(name.map { "${project.group}.${StringUtils.toPascalCase(it)}" })
-            version.convention(provider { project.version.toString() })
-            apiVersion.convention(provider { bukkit.parsedApiVersion.get() }.map(::resolveDefaultApiVersion))
-            url.convention(provider { providers.gradleProperty("url").orNull })
-        }
-    }
-
     /** Sets encoding on compile to UTF-8. */
     private fun Project.configureEncoding() {
         tasks.withType<JavaCompile>().configureEach {
@@ -69,12 +59,4 @@ public class BukkitGradlePlugin : Plugin<Project> {
             mavenCentral()
         }
     }
-
-    private fun resolveDefaultApiVersion(version: MinecraftVersion): String = when {
-        // "API version" has been introduced in Spigot 1.13
-        version < MinecraftVersion.V1_13_0 -> ""
-        // From 1.20.5 and onward, a patch version is supported.
-        version < MinecraftVersion.V1_20_5 -> version.withoutPatch().toString()
-        else -> version.toString()
-    }
 }

src/main/kotlin/extensions/Accessors.kt

@@ -2,7 +2,16 @@ package ru.endlesscode.bukkitgradle.extensions
 
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.tasks.SourceSet
+import org.gradle.api.tasks.SourceSetContainer
 import org.gradle.kotlin.dsl.the
+import xyz.jpenilla.resourcefactory.ResourceFactoryExtension
 
 internal val Project.java: JavaPluginExtension
     get() = the()
+
+internal val Project.sourceSets: SourceSetContainer
+    get() = the()
+
+internal val SourceSet.resourceFactory: ResourceFactoryExtension
+    get() = the()

src/main/kotlin/extensions/Provider.kt

@@ -5,7 +5,19 @@ import org.gradle.api.file.Directory
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import java.io.File
+import java.util.*
 
 internal fun <T> Property<T>.finalizedOnRead(): Property<T> = apply { finalizeValueOnRead() }
 
+// See: https://github.com/gradle/gradle/issues/12388
+@Suppress("UnstableApiUsage")
+internal fun <T : Any, R : Any> Provider<T>.mapNotNull(transform: (T) -> R?): Provider<R> {
+    return map { value: T ->
+        val transformedValue = transform(value)
+        Optional.ofNullable(transformedValue)
+    }
+        .filter(Optional<R>::isPresent)
+        .map(Optional<R>::get)
+}
+
 internal fun Project.directoryProvider(file: () -> File?): Provider<Directory> = layout.dir(provider(file))

src/main/kotlin/plugin/BukkitPluginYamlDefaults.kt

@@ -0,0 +1,76 @@
+@file:UseSerializers(PermissionDefaultSerializer::class)
+
+package ru.endlesscode.bukkitgradle.plugin
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.UseSerializers
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import xyz.jpenilla.resourcefactory.bukkit.BukkitPluginYaml
+import xyz.jpenilla.resourcefactory.bukkit.Permission.Default as PermissionDefault
+
+/**
+ * Should be synced with [BukkitPluginYaml.Serializable].
+ * We can't use the existing class as we want all fields to be nullable.
+ */
+@Serializable
+internal data class BukkitPluginYamlDefaults(
+    val apiVersion: String? = null,
+    val name: String? = null,
+    val version: String? = null,
+    val main: String? = null,
+    val description: String? = null,
+    val load: BukkitPluginYaml.PluginLoadOrder? = null,
+    val author: String? = null,
+    val authors: List<String>? = null,
+    val website: String? = null,
+    val depend: List<String>? = null,
+    val softdepend: List<String>? = null,
+    val loadbefore: List<String>? = null,
+    val prefix: String? = null,
+    val defaultPermission: PermissionDefault? = null,
+    val provides: List<String>? = null,
+    val libraries: List<String>? = null,
+    val commands: Map<String, Command>? = null,
+    val permissions: Map<String, Permission>? = null,
+    val foliaSupported: Boolean? = null,
+    val paperPluginLoader: String? = null,
+    val paperSkipLibraries: Boolean? = null,
+) {
+
+    @Serializable
+    internal data class Command(
+        val description: String? = null,
+        val aliases: List<String>? = null,
+        val permission: String? = null,
+        val permissionMessage: String? = null,
+        val usage: String? = null,
+    )
+
+    @Serializable
+    internal data class Permission(
+        val description: String? = null,
+        val default: PermissionDefault? = null,
+        val children: Map<String, Boolean>? = null,
+    )
+}
+
+internal object PermissionDefaultSerializer : KSerializer<PermissionDefault> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor(
+        "xyz.jpenilla.resourcefactory.bukkit.Permission.Default",
+        PrimitiveKind.STRING,
+    )
+
+    override fun deserialize(decoder: Decoder): PermissionDefault {
+        val string = decoder.decodeString()
+        return PermissionDefault.values().first { it.serialized.equals(string, ignoreCase = true) }
+    }
+
+    override fun serialize(encoder: Encoder, value: PermissionDefault) {
+        encoder.encodeString(value.serialized)
+    }
+}