migrate to gradle to kotlin

buildSrc/build.gradle.kts

@@ -0,0 +1,29 @@
+plugins {
+    `kotlin-dsl`
+    kotlin("jvm") version embeddedKotlinVersion
+}
+
+repositories {
+    jcenter()
+    gradlePluginPortal()
+}
+
+configurations.all {
+    resolutionStrategy {
+        // Fabric needs this.
+        force(
+                "commons-io:commons-io:2.5",
+                "org.ow2.asm:asm:7.1",
+                "org.ow2.asm:asm-commons:7.1"
+        )
+    }
+}
+
+dependencies {
+    implementation(gradleApi())
+    implementation("org.ajoberstar.grgit:grgit-gradle:3.1.1")
+    implementation("com.github.jengelman.gradle.plugins:shadow:5.1.0")
+    implementation("net.ltgt.apt-eclipse:net.ltgt.apt-eclipse.gradle.plugin:0.21")
+    implementation("net.ltgt.apt-idea:net.ltgt.apt-idea.gradle.plugin:0.21")
+    implementation("org.jfrog.buildinfo:build-info-extractor-gradle:4.9.7")
+}

buildSrc/src/main/kotlin/CommonConfig.kt

@@ -0,0 +1,27 @@
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.repositories
+
+fun Project.applyCommonConfiguration() {
+    group = rootProject.group
+    version = rootProject.version
+
+    repositories {
+        mavenCentral()
+        mavenLocal()
+        maven { url = uri("http://ci.athion.net/job/PlotSquared-Breaking/ws/mvn/") }
+        maven { url = uri("https://maven.sk89q.com/repo/") }
+        maven { url = uri("https://oss.sonatype.org/content/repositories/snapshots/") }
+        maven { url = uri("http://empcraft.com/maven2") }
+        maven { url = uri("https://repo.destroystokyo.com/repository/maven-public") }
+        maven { url = uri("https://ci.athion.net/job/FAWE-Piston/ws/") }
+        ivy { url = uri("https://ci.athion.net/job")
+            patternLayout {
+                artifact("/[organisation]/[module]/artifact/[revision].[ext]")
+            }}
+    }
+    configurations.all {
+        resolutionStrategy {
+            cacheChangingModulesFor(5, "minutes")
+        }
+    }
+}

buildSrc/src/main/kotlin/GradleExtras.kt

@@ -0,0 +1,12 @@
+import org.gradle.api.Project
+import org.gradle.api.plugins.ExtraPropertiesExtension
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.tasks.SourceSetContainer
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.the
+
+val Project.ext: ExtraPropertiesExtension
+    get() = extensions.getByType()
+
+val Project.sourceSets: SourceSetContainer
+    get() = the<JavaPluginConvention>().sourceSets

buildSrc/src/main/kotlin/LibsConfig.kt

@@ -0,0 +1,97 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.Project
+import org.gradle.api.artifacts.ModuleDependency
+import org.gradle.api.internal.HasConvention
+import org.gradle.api.plugins.MavenRepositoryHandlerConvention
+import org.gradle.api.tasks.Upload
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.getPlugin
+import org.gradle.kotlin.dsl.invoke
+import org.gradle.kotlin.dsl.register
+
+fun Project.applyLibrariesConfiguration() {
+    applyCommonConfiguration()
+    apply(plugin = "java-base")
+    apply(plugin = "maven")
+    apply(plugin = "com.github.johnrengelman.shadow")
+    apply(plugin = "com.jfrog.artifactory")
+
+    configurations {
+        create("shade")
+        getByName("archives").extendsFrom(getByName("default"))
+    }
+
+    group = "${rootProject.group}.worldedit-libs"
+
+    tasks.register<ShadowJar>("jar") {
+        configurations = listOf(project.configurations["shade"])
+        archiveClassifier.set("")
+
+        dependencies {
+            exclude(dependency("com.google.guava:guava"))
+            exclude(dependency("com.google.code.gson:gson"))
+            exclude(dependency("org.checkerframework:checker-qual"))
+        }
+
+        relocate("net.kyori.text", "com.sk89q.worldedit.util.formatting.text")
+    }
+    val altConfigFiles = { artifactType: String ->
+        val deps = configurations["shade"].incoming.dependencies
+                .filterIsInstance<ModuleDependency>()
+                .map { it.copy() }
+                .map { dependency ->
+                    dependency.artifact {
+                        name = dependency.name
+                        type = artifactType
+                        extension = "jar"
+                        classifier = artifactType
+                    }
+                    dependency
+                }
+
+        files(configurations.detachedConfiguration(*deps.toTypedArray())
+                .resolvedConfiguration.lenientConfiguration.artifacts
+                .filter { it.classifier == artifactType }
+                .map { zipTree(it.file) })
+    }
+    tasks.register<Jar>("sourcesJar") {
+        from({
+            altConfigFiles("sources")
+        })
+        val filePattern = Regex("(.*)net/kyori/text((?:/|$).*)")
+        val textPattern = Regex("net\\.kyori\\.text")
+        eachFile {
+            filter {
+                it.replaceFirst(textPattern, "com.sk89q.worldedit.util.formatting.text")
+            }
+            path = path.replaceFirst(filePattern, "$1com/sk89q/worldedit/util/formatting/text$2")
+        }
+        archiveClassifier.set("sources")
+    }
+
+    tasks.named("assemble").configure {
+        dependsOn("jar", "sourcesJar")
+    }
+
+    artifacts {
+        val jar = tasks.named("jar")
+        add("default", jar) {
+            builtBy(jar)
+        }
+        val sourcesJar = tasks.named("sourcesJar")
+        add("archives", sourcesJar) {
+            builtBy(sourcesJar)
+        }
+    }
+
+    tasks.register<Upload>("install") {
+        configuration = configurations["archives"]
+        (repositories as HasConvention).convention.getPlugin<MavenRepositoryHandlerConvention>().mavenInstaller {
+            pom.version = project.version.toString()
+            pom.artifactId = project.name
+        }
+    }
+
+}

buildSrc/src/main/kotlin/PlatformConfig.kt

@@ -0,0 +1,108 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.JavaVersion
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.plugins.quality.CheckstyleExtension
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.api.tasks.javadoc.Javadoc
+import org.gradle.api.tasks.testing.Test
+import org.gradle.external.javadoc.CoreJavadocOptions
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.getByName
+import org.gradle.kotlin.dsl.named
+import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.withType
+
+fun Project.applyPlatformAndCoreConfiguration() {
+    applyCommonConfiguration()
+    apply(plugin = "java")
+    apply(plugin = "eclipse")
+    apply(plugin = "idea")
+    apply(plugin = "maven")
+    apply(plugin = "checkstyle")
+    apply(plugin = "com.github.johnrengelman.shadow")
+    apply(plugin = "com.jfrog.artifactory")
+
+    ext["internalVersion"] = "$version;${rootProject.ext["gitCommitHash"]}"
+
+    configure<JavaPluginConvention> {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    configure<CheckstyleExtension> {
+        configFile = rootProject.file("config/checkstyle/checkstyle.xml")
+        toolVersion = "7.6.1"
+    }
+
+    tasks.withType<Test>().configureEach {
+        useJUnitPlatform()
+    }
+
+    dependencies {
+        "compileOnly"("org.jetbrains:annotations:17.0.0")
+        "testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.JUNIT}")
+        "testImplementation"("org.junit.jupiter:junit-jupiter-params:${Versions.JUNIT}")
+        "testImplementation"("org.mockito:mockito-core:${Versions.MOCKITO}")
+        "testImplementation"("org.mockito:mockito-junit-jupiter:${Versions.MOCKITO}")
+        "testRuntime"("org.junit.jupiter:junit-jupiter-engine:${Versions.JUNIT}")
+    }
+
+    // Java 8 turns on doclint which we fail
+    tasks.withType<Javadoc>().configureEach {
+        (options as CoreJavadocOptions).addStringOption("Xdoclint:none", "-quiet")
+    }
+
+    tasks.register<Jar>("javadocJar") {
+        dependsOn("javadoc")
+        archiveClassifier.set("javadoc")
+        from(tasks.getByName<Javadoc>("javadoc").destinationDir)
+    }
+
+    tasks.named("assemble").configure {
+        dependsOn("javadocJar")
+    }
+
+    artifacts {
+        add("archives", tasks.named("jar"))
+        add("archives", tasks.named("javadocJar"))
+    }
+
+    if (name == "worldedit-core" || name == "worldedit-bukkit") {
+        tasks.register<Jar>("sourcesJar") {
+            dependsOn("classes")
+            archiveClassifier.set("sources")
+            from(sourceSets["main"].allSource)
+        }
+
+        artifacts {
+            add("archives", tasks.named("sourcesJar"))
+        }
+        tasks.named("assemble").configure {
+            dependsOn("sourcesJar")
+        }
+    }
+
+    tasks.named("check").configure {
+        dependsOn("checkstyleMain", "checkstyleTest")
+    }
+
+}
+
+fun Project.applyShadowConfiguration() {
+    tasks.named<ShadowJar>("shadowJar") {
+        archiveClassifier.set("dist")
+        dependencies {
+            include(project(":worldedit-libs:core"))
+            include(project(":worldedit-libs:${project.name.replace("worldedit-", "")}"))
+            include(project(":worldedit-core"))
+        }
+        exclude("GradleStart**")
+        exclude(".cache")
+        exclude("LICENSE*")
+        minimize()
+    }
+}

buildSrc/src/main/kotlin/Versions.kt

@@ -0,0 +1,8 @@
+object Versions {
+    const val TEXT = "3.0.1"
+    const val TEXT_EXTRAS = "3.0.2"
+    const val PISTON = "0.4.4-SNAPSHOT"
+    const val AUTO_VALUE = "1.6.5"
+    const val JUNIT = "5.5.0"
+    const val MOCKITO = "3.0.0"
+}