build.gradle

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

plugins {
    id 'java'
    id "xyz.jpenilla.run-paper" version "2.3.1"
    id "com.gradleup.shadow" version "8.3.6"
}

def IS_WORKFLOW = project.hasProperty('Workflow')
def LUAJAVA_DIR = project.layout.projectDirectory.dir("luajava").asFile

ext.targetJavaVersion = 8
if (project.hasProperty('TargetJava')) {
    ext.targetJavaVersion = Integer.parseInt(project.property('TargetJava').toString())
}
if (project.targetJavaVersion <= 8) {
    execCommand("git apply ../patchs/luajava-java8.patch", LUAJAVA_DIR)
}
execCommand("git apply ../patchs/luajava-gradle.patch", LUAJAVA_DIR)

ext.gitHash    = getGitHash(project.rootDir)
ext.gitBranch  = execCommand("git rev-parse --abbrev-ref HEAD", project.rootDir)
ext.gitTag     = getGitTag(project.rootDir)
ext.gitVersion = project.gitTag == null ?
        "${project.gitBranch}-${project.gitHash}" : "${project.gitTag}"

ext.gitHashLuajava   = getGitHash(LUAJAVA_DIR)
ext.gitBranchLuajava = execCommand("git rev-parse --abbrev-ref HEAD", LUAJAVA_DIR)
ext.gitTagLuajava    = getGitTag(LUAJAVA_DIR)
ext.luajavaVersion   = project.gitTagLuajava == null ?
        "${project.gitBranchLuajava}-${project.gitHashLuajava}" : "${project.gitTagLuajava}"

ext.apiPath   = "org/eu/smileyik/luaInMinecraftBukkitII/api/**"

group = 'org.eu.smileyik'
version = project.gitTag == null ?
        "${project.gitVersion}+luajava-${project.luajavaVersion}+java-${project.targetJavaVersion}" :
        "${project.gitVersion}"
if (gradle.foliaSupport) version += "+folia"

repositories {
    mavenCentral()
    maven {
        name = "spigotmc-repo"
        url = "https://hub.spigotmc.org/nexus/content/repositories/snapshots/"
    }
    maven {
        name = "sonatype"
        url = "https://oss.sonatype.org/content/groups/public/"
    }
    if (IS_WORKFLOW) {
        maven {
            url "https://raw.githubusercontent.com/SmileYik/LuaInMinecraftBukkitII/refs/heads/gh-page/repo"
        }
    } else {
        maven {
            url "https://maven-v4.smileyik.eu.org:60081/public"
        }
        maven {
            url "https://maven.smileyik.eu.org:60081/public"
        }
    }

}

dependencies {
    testImplementation platform('org.junit:junit-bom:5.10.0')
    testImplementation 'org.junit.jupiter:junit-jupiter'

    annotationProcessor 'org.jetbrains:annotations:24.0.0'
    annotationProcessor 'org.projectlombok:lombok:1.18.30'
    compileOnly 'org.jetbrains:annotations:24.0.0'
    compileOnly 'org.projectlombok:lombok:1.18.30'

    compileOnly("org.spigotmc:spigot-api:1.18.2-R0.1-SNAPSHOT")
    testImplementation("org.spigotmc:spigot-api:1.18.2-R0.1-SNAPSHOT")

    implementation project(":luajava:java")
    // command
    implementation("org.eu.smileyik:SimpleCommand:1.0.7-SNAPSHOT")
    // SimpleDebug
    implementation 'org.eu.smileyik:SimpleDebug:1.0.2-SNAPSHOT'
    // byte buddy
    implementation 'net.bytebuddy:byte-buddy:1.14.3'
    // bstats
    implementation 'org.bstats:bstats-bukkit:3.0.2'

    // scheduler
    implementation project(":scheduler")
    if (gradle.foliaSupport) {
        implementation project(":scheduler:scheduler-folia")
    }
}

tasks {
    runServer {
        // Configure the Minecraft version for our task.
        // This is the only required configuration besides applying the plugin.
        // Your plugin's jar (or shadowJar if present) will be used automatically.
        minecraftVersion("1.21.5")
    }
}


test {
    useJUnitPlatform()
}

def targetJavaVersion = ext.targetJavaVersion
java {
    def javaVersion = JavaVersion.toVersion(targetJavaVersion)
    sourceCompatibility = javaVersion
    targetCompatibility = javaVersion
    if (JavaVersion.current() < javaVersion) {
        toolchain.languageVersion = JavaLanguageVersion.of(targetJavaVersion)
    }
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'

    if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible()) {
        options.release.set(targetJavaVersion)
    }
}

processResources {
    def props = [
            version: version,
            foliaSupported: gradle.foliaSupport
    ]
    inputs.properties props
    filteringCharset 'UTF-8'
    filesMatching('plugin.yml') {
        expand props
    }
}

classes {
    // restore patch
    doLast {
        generateResourceList(layout.buildDirectory.dir("resources/main/resources").get())
        exec {
            workingDir layout.projectDirectory.dir("luajava")
            commandLine 'git', 'restore', '*'
        }
    }
}

shadowJar {
    relocate 'org.eu.smileyik.simpledebug', 'org.eu.smileyik.luaInMinecraftBukkitII.simpledebug'
    relocate 'org.eu.smileyik.simplecommand', 'org.eu.smileyik.luaInMinecraftBukkitII.simplecommand'
    relocate 'net.bytebuddy', 'org.eu.smileyik.luaInMinecraftBukkitII.bytebuddy'
    relocate 'org.bstats', 'org.eu.smileyik.luaInMinecraftBukkitII.bstats'

    manifest {
        attributes 'Build-Timestamp': System.currentTimeMillis()
    }
}

javadoc {
    failOnError false
    options {
        encoding 'UTF-8'
        charSet 'UTF-8'
        author true
        version true
    }
}

tasks.register('sourcesJar', Jar) {
    group = "custom jar"
    dependsOn classes
    archiveClassifier = 'sources'

    from sourceSets.main.allSource
}

tasks.register("javadocJar", Jar) {
    group = "custom jar"
    dependsOn javadoc
    archiveClassifier = 'javadoc'

    from javadoc.destinationDir
}

tasks.register("apiJavadoc", Javadoc) {
    destinationDir file("${destinationDir}/../api-javadoc/")
    failOnError false
    options {
        encoding 'UTF-8'
        charSet 'UTF-8'
        author true
        version true
    }
    source = sourceSets.main.allJava
    include project.apiPath
}

tasks.register("apiJar", ShadowJar) {
    group = "custom jar"
    description = "Create Jar file just include api"
    archiveClassifier = "api"
    from sourceSets.main.output
    include project.apiPath
}

tasks.register("apiJavadocJar", ShadowJar) {
    group = "custom jar"
    dependsOn apiJavadoc
    description = "Create a Javadoc for api Jar"
    archiveClassifier = "api-javadoc"
    from apiJavadoc.destinationDir
}

tasks.register("apiSourcesJar", ShadowJar) {
    group = "custom jar"
    description = "Create a Javadoc for api Jar"
    archiveClassifier = "api-sources"
    from sourceSets.main.allSource
    include project.apiPath
}

build {
    dependsOn apiJar, apiJavadocJar, apiSourcesJar, javadocJar, sourcesJar, shadowJar
}

static def execCommand(command, dir) {
    def output = "unknown"
    try {
        def process = command.execute(null, dir)
        process.waitFor()
        if (process.exitValue() == 0) {
            output = process.text.trim()
        }
    } catch (Exception ignore) {

    }
    return output
}

static def getGitTag(dir) {
    def tag = execCommand("git describe --tags --exact-match", dir)
    return tag == "unknown" ? null : tag
}

static def getGitHash(dir) {
    def hash = execCommand("git rev-parse HEAD", dir)
    return hash == "unknown" ? hash : hash.substring(0, 7)
}

static def generateResourceList(Directory dir) {
    dir.asFile.listFiles()?.findAll { it.isDirectory() }?.each {
        def parent = dir.dir(it.name)
        def prefixLength = "$parent".length() + 1
        def list = parent.asFileTree.collect {
            it.toString().substring(prefixLength)
        }
        dir.file(it.name + ".list").asFile.write(list.join("\n"))
    }
}