build.gradle

/*
 * Copyright (c) 2018-2020 Karlatemp. All rights reserved.
 * @author Karlatemp <karlatemp@vip.qq.com> <https://github.com/Karlatemp>
 *
 * LuckPerms-Mirai/LuckPerms-Mirai/build.gradle
 *
 * Use of this source code is governed by the GNU AFFERO GENERAL PUBLIC LICENSE version 3 license that can be found via the following link.
 *
 * https://github.com/Karlatemp/LuckPerms-Mirai/blob/master/LICENSE
 */

import java.nio.file.Files

plugins {
    id 'java'
    id 'java-library'
    id 'org.jetbrains.kotlin.jvm' version '1.7.10'
    id 'com.github.johnrengelman.shadow' version '7.1.2'
}

def lpVersion = ({
    def resu
    gradle.includedBuild("LuckPerms").properties.availableModules.each { module ->
        ModuleVersionIdentifier m = module.left()
        if (m.name == 'common') {
            resu = m.version
        }
    }
    return resu
})().toString()

def getGitVersion = { String path ->
    def proc = new ProcessBuilder("git", "rev-parse", "HEAD")
            .directory(new File(rootProject.projectDir, path))
            .start()
    proc.waitFor()
    def line = proc.inputStream.withReader { it.readLine() }
    return line
}

def gitVersion = getGitVersion(".")
def gitLpVersion = getGitVersion("LuckPerms")

def now = System.currentTimeMillis()

println("GitVersion = $gitVersion")
println("LpGVersion = $gitLpVersion")

// [LP-Mirai version]-[LuckPerms version]
def lpMiraiVer = '2.14.0-dev-8'
def ver = lpMiraiVer + '+' + lpVersion

allprojects {
    group 'io.github.karlatemp.mirai.luckperms'
    if (name == 'public-api') {
        version lpMiraiVer
    } else {
        version ver
    }

    repositories {
        mavenLocal()
        mavenCentral()
    }
    afterEvaluate {
        compileKotlin {
            kotlinOptions {
                jvmTarget = '1.8'
                freeCompilerArgs += [
                        '-Xopt-in=kotlin.RequiresOptIn',
                        '-Xopt-in=io.github.karlatemp.luckperms.mirai.openapi.anno.InternalLpApi',
                        '-Xopt-in=io.github.karlatemp.luckperms.mirai.openapi.anno.ExperimentalLpApi',
                        '-Xjvm-default=enable'
                ]
            }
        }
    }
}

dependencies {
    // https://mvnrepository.com/artifact/io.github.karlatemp/unsafe-accessor
    implementation group: 'io.github.karlatemp', name: 'unsafe-accessor', version: '1.4.0'

    // https://mvnrepository.com/artifact/org.fusesource.jansi/jansi
    compileOnly group: 'org.fusesource.jansi', name: 'jansi', version: '1.18'
    api 'org.spongepowered:configurate-hocon:3.7.1'
    // https://mvnrepository.com/artifact/com.google.code.gson/gson
    api group: 'com.google.code.gson', name: 'gson', version: '2.8.6'

    api "me.lucko.luckperms:common" // LuckPerms
    api project(':public-api')

    compileOnly(project.property('versions.mirai-core-api'))
    compileOnly(project.property('versions.mirai-console'))
//
//    ({
//        def console = rootProject.file("../Mirai-console/backend/mirai-console/build/libs")
//        if (console.isDirectory() && console.listFiles().length > 0) {
//            compileOnly(fileTree(console))
//            compileOnly("com.vdurmont:semver4j:3.1.0")
//        } else {
//            compileOnly("net.mamoe:mirai-console:1.0-M4-dev-3") // 后端
//        }
//    })()
    compileOnly "org.jetbrains.kotlin:kotlin-stdlib"
    testApi group: 'junit', name: 'junit', version: '4.12'


}

processResources {
    from(sourceSets.main.resources.srcDirs) {
        expand([
                'pluginVersion': ver,
                'lpVersion'    : lpVersion,
                'lpmVersion'   : lpMiraiVer,
                'gitLuckPerms' : gitLpVersion,
                'gitPlugin'    : gitVersion,
                'buildTime'    : now
        ])
        include 'plugin.yml'
        include 'metainfo.conf'
    }
    duplicatesStrategy = DuplicatesStrategy.INCLUDE
}

shadowJar {
    exclude 'module-info.class'
    relocate 'io.github.karlatemp.unsafeaccessor', 'me.lucko.luckperms.lib.unsafeaccessor'
    relocate 'net.kyori.adventure', 'me.lucko.luckperms.lib.adventure'
    relocate 'net.kyori.event', 'me.lucko.luckperms.lib.eventbus'
    relocate 'com.github.benmanes.caffeine', 'me.lucko.luckperms.lib.caffeine'
    relocate 'okio', 'me.lucko.luckperms.lib.okio'
    relocate 'okhttp3', 'me.lucko.luckperms.lib.okhttp3'
    relocate 'net.bytebuddy', 'me.lucko.luckperms.lib.bytebuddy'
    relocate 'me.lucko.commodore', 'me.lucko.luckperms.lib.commodore'
    relocate 'org.mariadb.jdbc', 'me.lucko.luckperms.lib.mariadb'
    relocate 'com.mysql', 'me.lucko.luckperms.lib.mysql'
    relocate 'org.postgresql', 'me.lucko.luckperms.lib.postgresql'
    relocate 'com.zaxxer.hikari', 'me.lucko.luckperms.lib.hikari'
    relocate 'com.mongodb', 'me.lucko.luckperms.lib.mongodb'
    relocate 'org.bson', 'me.lucko.luckperms.lib.bson'
    relocate 'redis.clients.jedis', 'me.lucko.luckperms.lib.jedis'
    relocate 'org.apache.commons.pool2', 'me.lucko.luckperms.lib.commonspool2'
    relocate 'com.rabbitmq', 'me.lucko.luckperms.lib.rabbitmq'
    // relocate 'ninja.leaping.configurate', 'me.lucko.luckperms.lib.configurate'

    def excludes = [
            'com.zaxxer:HikariCP',
            'org.slf4j',
            'me.lucko:adventure-api',
            'net.bytebuddy',
            'net.kyori',
            'org.spongepowered:configurate-yaml',
            'org.yaml:snakeyaml',
            'redis.clients',
            'com.github.ben-manes.caffeine',
            'com.squareup.okhttp3',
            'com.squareup.okio',
            'me.lucko.configurate',
            'org.mongodb',
            'org.apache.commons'
    ]
    dependencyFilter.exclude {
        excludes.contains(it.moduleGroup + ":" + it.moduleName) || excludes.contains(it.moduleGroup)
    }
}


task releaseCiJar() {
    group = "build"
    dependsOn(shadowJar)
    doFirst {
        def file = shadowJar.archiveFile.get().asFile
        def target = rootProject.file("build/ci")
        target.mkdirs()
        def targetFile = new File(target, "luckperms-mirai.jar")
        targetFile.delete()
        file.withInputStream { stream ->
            Files.copy(stream, targetFile.toPath())
        }
    }
}

task ts47() {
}

compileKotlin {
    kotlinOptions {
        jvmTarget = '1.8'
        freeCompilerArgs += ['-Xopt-in=kotlin.RequiresOptIn',
                             '-Xjvm-default=enable']
    }
}
compileTestKotlin {
    kotlinOptions {
        jvmTarget = '1.8'
        freeCompilerArgs += ['-Xopt-in=kotlin.RequiresOptIn',
                             '-Xjvm-default=enable']
    }
}


task genPatch() {
    group = "patchs"
    doLast {
        def code = new ProcessBuilder(
                "git", "diff", "--output", "../patchs.patch"
        )
                .directory(project.file("LuckPerms"))
                .inheritIO()
                .start()
                .waitFor()
        if (code != 0) {
            throw new IllegalStateException("Code: $code")
        }
    }
}

task applyPatch() {
    group = "patchs"
    doLast {
        def proc = new ProcessBuilder(
                "git", "apply", "--reject", "../patchs.patch"
        )
                .directory(project.file("LuckPerms"))
                .inheritIO()
                .start()
        proc.in.eachLine { println it }
        proc.err.eachLine { System.err.println it }
        def code = proc.waitFor()
        if (code != 0) {
            throw new IllegalStateException("Code: $code")
        }
    }
}