Initial commit

build.gradle.kts

@@ -0,0 +1,251 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.snakeyaml.engine.v2.api.Dump
+import org.snakeyaml.engine.v2.api.DumpSettings
+import org.snakeyaml.engine.v2.api.Load
+import org.snakeyaml.engine.v2.api.LoadSettings
+import java.util.stream.Collectors
+
+group = "net.eratiem"
+version = "0.1-SNAPSHOT"
+
+plugins {
+  alias(libs.plugins.kotlin.jvm)
+  alias(libs.plugins.shadow)
+
+  alias(libs.plugins.paperweight.userdev) apply false
+
+  idea
+}
+
+// Load SnakeYaml
+buildscript {
+  dependencies {
+    classpath(libs.snakeyaml)
+  }
+}
+
+// Command YAMLs
+val yamlLoad by lazy { Load(LoadSettings.builder().build()) }
+val yamlDump by lazy { Dump(DumpSettings.builder().build()) }
+val loadYaml = { it: String ->
+  val file = project.file(it)
+  if (!file.exists()) file.createNewFile()
+
+  project.file(it).bufferedReader().use { reader ->
+    yamlLoad.loadFromReader(reader) as? LinkedHashMap<*, *>
+  }
+}
+val commands by lazy { loadYaml("commands.yml") }
+val proxyCommands by lazy { loadYaml("proxyCommands.yml") }
+
+
+subprojects {
+  this.group = rootProject.group
+  this.version = rootProject.version
+
+  repositories {
+    bitBuildArtifactory()
+
+    rootProject.ext["bitBuildArtifactoryPublish"] = bitBuildArtifactory(useCredentials = true, publish = true)
+    rootProject.ext["githubPackagesPublish"] = githubPackages(true)
+  }
+
+  apply {
+    plugin(rootProject.libs.plugins.kotlin.jvm.get().pluginId)
+    plugin(rootProject.libs.plugins.shadow.get().pluginId)
+
+    if (project.name in arrayOf("paper", "spigot", "folia"))
+      plugin(rootProject.libs.plugins.paperweight.userdev.get().pluginId)
+  }
+
+  dependencies {
+    val tools: Project? = findProject(":tools")
+    if (tools != null && tools != project) implementation(project(path = ":tools", configuration = "shadow"))
+
+    compileOnly(rootProject.libs.kotlin.gradleplugin)
+    compileOnly(rootProject.libs.kotlin.stdlib)
+
+    compileOnly(rootProject.libs.minecraft.plugin.eralogger)
+  }
+
+  configurations {
+    create("shadowJarDependencies").apply {
+      extendsFrom(project.configurations.implementation.get())
+      isCanBeResolved = true
+    }
+  }
+
+  tasks {
+    shadowJar {
+      group = "plugin"
+      enabled = true
+      dependsOn(classes)
+
+      configurations = listOf(
+        project.configurations.getByName("shadowJarDependencies")
+      )
+
+      archiveBaseName.set(rootProject.name)
+      archiveClassifier.set(null as String?)
+      if (project.name != "tools")
+        archiveAppendix.set(project.name)
+
+    }
+    if (project.name == "tools")
+      rootProject.ext["toolsArtifact"] = shadowJar
+
+    /**
+     * Copy Task to fill plugin.yml
+     */
+    if (project.name !in arrayOf("tools", "velocity")) {
+      withType<Copy> {
+        outputs.upToDateWhen { false }
+
+        val mainClass = "${project.group}.${rootProject.name.lowercase()}.${project.properties["mainClass"]}"
+        val pluginDescription: String by project
+        val pluginDependencies = getAsYamlList(project.properties["pluginDependencies"])
+        val pluginSoftDependencies = getAsYamlList(project.properties["pluginSoftdependencies"])
+        val authors: String = getAsYamlList(project.properties["authors"])
+        val commands: String = if (
+          (project.properties["splitCommandYaml"] as? Boolean == true) &&
+          project.name in arrayOf("bungeecord", "waterfall")
+        ) {
+          proxyCommands?.let { commandsDumpOptimization(yamlDump.dumpToString(it)) } ?: "[]"
+        } else {
+          commands?.let { commandsDumpOptimization(yamlDump.dumpToString(it)) } ?: "[]"
+        }
+
+        val props: LinkedHashMap<String, String> = linkedMapOf(
+          "plugin_name" to rootProject.name,
+          "plugin_description" to pluginDescription,
+          "plugin_version" to version.toString(),
+          "plugin_main_class" to mainClass,
+          "plugin_dependencies" to pluginDependencies,
+          "plugin_softdependencies" to pluginSoftDependencies,
+          "plugin_authors" to authors,
+          "plugin_commands" to commands
+        )
+
+        filesMatching("plugin.yml") {
+          val api = when (project.name) {
+            "spigot" -> rootProject.libs.versions.plugin.spigot
+            "paper" -> rootProject.libs.versions.plugin.paper
+            "folia" -> rootProject.libs.versions.plugin.folia
+            "bungeecord" -> rootProject.libs.versions.plugin.bungeecord
+            else -> rootProject.libs.versions.plugin.waterfall
+          }
+          props["plugin_api_version"] = api.get()
+
+          expand(props)
+        }
+      }
+    }
+
+    // Disable standard jar task
+    jar {
+      enabled = false
+    }
+
+    // Compile Stuff
+    val javaVersion = JavaVersion.VERSION_17
+    withType<JavaCompile> {
+      options.encoding = "UTF-8"
+      options.release.set(javaVersion.toString().toInt())
+    }
+
+    java {
+      toolchain.languageVersion.set(JavaLanguageVersion.of(javaVersion.toString()))
+    }
+
+    withType<KotlinCompile> {
+      kotlinOptions.jvmTarget = javaVersion.toString()
+    }
+  }
+}
+
+fun getAsYamlList(commaSeparatedList: Any?): String =
+  if (commaSeparatedList is String && commaSeparatedList.isNotBlank()) {
+    commaSeparatedList
+      .replace(" ", "")
+      .split(",")
+      .stream()
+      .map { "\n  - $it" }
+      .collect(Collectors.joining())
+  } else ""
+
+fun commandsDumpOptimization(commandsDump: String?) = commandsDump?.let {
+  it.split("\n")
+    .joinToString("\n", "\n") { line -> "  $line" }
+}
+
+repositories {
+  bitBuildArtifactory()
+}
+
+tasks {
+  // Disable standard jar task
+  jar {
+    enabled = false
+  }
+
+  shadowJar {
+    enabled = false
+  }
+}
+
+idea {
+  module {
+    isDownloadSources = true
+    isDownloadJavadoc = true
+  }
+}
+
+fun RepositoryHandler.bitBuildArtifactory(
+  useCredentials: Boolean = false, publish: Boolean = false
+): MavenArtifactRepository {
+  val url: String
+  val name: String
+  if (publish) {
+    val nonReleaseStrings = listOf("snapshot", "alpha", "beta", "rc")
+    val isNonRelease =
+      nonReleaseStrings.any { project.version.toString().contains(it, true) }
+    url = "https://packages.bit-build.de/maven/p/eratiem-network/eratiem"
+    name = "BitBuildSpaceEraTiem"
+
+  } else {
+    url = "https://artifactory.bit-build.de/artifactory/public"
+    name = "BitBuildArtifactoryPublic"
+  }
+
+  return if (publish || useCredentials) createMavenRepo(url, name, "SPACE_USER", "SPACE_TOKEN")
+  else createMavenRepo(url, name)
+}
+
+fun RepositoryHandler.githubPackages(useCredentials: Boolean = true): MavenArtifactRepository {
+  val url = "https://maven.pkg.github.com/EraTiem-Network/${project.name}"
+  val name = "GitHub"
+
+  return if (useCredentials) createMavenRepo(url, name, "GITHUB_USER", "GITHUB_TOKEN")
+  else createMavenRepo(url, name)
+}
+
+fun RepositoryHandler.createMavenRepo(url: String, name: String) = maven {
+  this.url = uri(url)
+  this.name = name
+}
+
+fun RepositoryHandler.createMavenRepo(url: String, name: String, userEnv: String, passEnv: String) = maven {
+  this.url = uri(url)
+  this.name = name
+  val user: String? = System.getenv(userEnv)
+  val pass: String? = System.getenv(passEnv)
+
+  if (user == null || pass == null) {
+    logger.error("The environment variable $userEnv or $passEnv does not exist or is null!")
+  }
+
+  credentials {
+    username = System.getenv(userEnv)
+    password = System.getenv(passEnv)
+  }
+}