kotlin: Move PrepareServer to Kotlin

Author: osipxd

src/main/groovy/ru/endlesscode/bukkitgradle/server/legacy/LegacyDevServerPlugin.groovy

@@ -2,13 +2,15 @@ package ru.endlesscode.bukkitgradle.server.legacy
 
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.tasks.Copy
 import org.gradle.api.tasks.TaskProvider
-import ru.endlesscode.bukkitgradle.BukkitGradlePlugin
+import org.gradle.jvm.tasks.Jar
+import ru.endlesscode.bukkitgradle.meta.extension.PluginMeta
 import ru.endlesscode.bukkitgradle.server.ServerConstants
 import ru.endlesscode.bukkitgradle.server.extension.RunConfiguration
-import ru.endlesscode.bukkitgradle.server.legacy.task.PrepareServer
 import ru.endlesscode.bukkitgradle.server.task.CreateIdeaJarRunConfiguration
 import ru.endlesscode.bukkitgradle.server.task.GenerateRunningScript
+import ru.endlesscode.bukkitgradle.server.task.PrepareServer
 import ru.endlesscode.bukkitgradle.server.task.RunServer
 
 class LegacyDevServerPlugin implements Plugin<Project> {
@@ -23,13 +25,7 @@ class LegacyDevServerPlugin implements Plugin<Project> {
             scriptDir.set(serverCore.serverDir)
         }
 
-        def prepareServer = project.tasks.register('prepareServer', PrepareServer) {
-            group = BukkitGradlePlugin.GROUP
-            description = 'Prepare server ro run. Configure server and copy compiled plugin to plugins dir'
-            core = serverCore
-            dependsOn('build', 'copyServerCore')
-        } as TaskProvider<PrepareServer>
-
+        def prepareServer = configurePrepareServerTask(project, serverCore)
         project.tasks.register('runServer', RunServer) {
             scriptFile.set(generateRunningScript.map { it.scriptFile.get().asFile })
             dependsOn(prepareServer)
@@ -39,7 +35,26 @@ class LegacyDevServerPlugin implements Plugin<Project> {
             configurationName.set("$project.name: Run server")
             beforeRunTask.set('prepareServer')
             configurationsDir.set(project.rootProject.layout.projectDirectory.dir('.idea/runConfigurations'))
-            jarPath.set(prepareServer.map { it.serverDir.file(ServerConstants.FILE_CORE).get().asFile })
+            jarPath.set(new File(serverCore.serverDir, ServerConstants.FILE_CORE))
+        }
+    }
+
+    private static TaskProvider<PrepareServer> configurePrepareServerTask(Project project, ServerCore serverCore) {
+        def jarTaskName = project.plugins.hasPlugin("com.github.johnrengelman.shadow") ? "shadowJar" : "jar"
+        def jarTask = project.tasks.named(jarTaskName, Jar) as TaskProvider<Jar>
+        def meta = project.bukkit.meta as PluginMeta
+        def copyPlugins = project.tasks.register("copyPlugins", Copy) {
+            from(jarTask)
+            into(project.mkdir(new File(serverCore.serverDir, "plugins")))
+            rename { "${meta.name.get()}.jar" }
+        }
+
+        def run = project.bukkit.run as RunConfiguration
+        return project.tasks.register('prepareServer', PrepareServer) {
+            serverDir.set(serverCore.serverDir)
+            eula = run.eula
+            onlineMode = run.onlineMode
+            dependsOn('copyServerCore', copyPlugins)
         }
     }
 }

src/main/groovy/ru/endlesscode/bukkitgradle/server/legacy/task/PrepareServer.groovy

@@ -3,9 +3,11 @@ package ru.endlesscode.bukkitgradle
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.getByType
 import ru.endlesscode.bukkitgradle.meta.extension.PluginMeta
+import ru.endlesscode.bukkitgradle.server.extension.RunConfiguration
 
 public interface Bukkit {
     public val meta: PluginMeta
+    public val run: RunConfiguration
 }
 
 internal val Project.bukkit: Bukkit get() = extensions.getByType()

src/main/kotlin/Bukkit.kt

@@ -0,0 +1,70 @@
+package ru.endlesscode.bukkitgradle.server.task
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFile
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import ru.endlesscode.bukkitgradle.TASKS_GROUP_BUKKIT
+import java.util.*
+import javax.inject.Inject
+
+internal open class PrepareServer @Inject constructor(objects: ObjectFactory) : DefaultTask() {
+
+    @Internal
+    val serverDir: DirectoryProperty = objects.directoryProperty()
+
+    @Input
+    var eula: Boolean = false
+
+    @Input
+    var onlineMode: Boolean = true
+
+    @OutputFile
+    val eulaFile: Provider<RegularFile> = serverDir.map { it.file("eula.txt") }
+
+    @OutputFile
+    val propertiesFile: Provider<RegularFile> = serverDir.map { it.file("server.properties") }
+
+    init {
+        group = TASKS_GROUP_BUKKIT
+        description = "Prepare server to run. Configure eula and online-mode."
+    }
+
+    @TaskAction
+    fun prepareServer() {
+        resolveEula()
+        resolveOnlineMode()
+    }
+
+    private fun resolveEula() {
+        val eulaFile = eulaFile.get().asFile
+        if (!eulaFile.exists()) {
+            eulaFile.createNewFile()
+        }
+
+        val properties = Properties()
+        properties.load(eulaFile.reader())
+        properties.setProperty("eula", "$eula")
+        properties.store(
+            eulaFile.writer(),
+            "By changing the setting below to TRUE you are indicating your agreement to our EULA (https://account.mojang.com/documents/minecraft_eula)."
+        )
+    }
+
+    private fun resolveOnlineMode() {
+        val propsFile = propertiesFile.get().asFile
+        if (!propsFile.exists()) {
+            propsFile.createNewFile()
+        }
+
+        val properties = Properties()
+        properties.load(propsFile.reader())
+        properties.setProperty("online-mode", "$onlineMode")
+        properties.store(propsFile.writer(), "Minecraft server properties")
+    }
+}