build.gradle

import groovy.json.JsonSlurper
import org.jooq.codegen.DefaultGeneratorStrategy
import org.jooq.codegen.GenerationTool
import org.jooq.meta.Definition
import org.jooq.meta.DefaultDataTypeDefinition
import org.jooq.meta.jaxb.*
import org.jooq.tools.StringUtils

apply plugin: "java"
apply plugin: "maven-publish"

group = "stellar.database"
version = "1.5.0"

sourceCompatibility = 16

compileJava.options.encoding = "UTF-8"
compileTestJava.options.encoding = "UTF-8"

def getGitHash = { ->
    def stdout = new ByteArrayOutputStream()
    exec {
        commandLine "git", "rev-parse", "--short", "HEAD"
        standardOutput = stdout
    }
    return stdout.toString().trim()
}

ext {
    mindustryVersion = "v146"
    lombokVersion = "1.18.24"
    mysqlVersion = "8.0.30"
    postresqlVersion = "42.7.3"
    jooqVersion = "3.17.0"
    hikariVersion = "5.0.1"
    jacksonVersion = "2.17.2"
}

repositories {
    mavenCentral()
    maven { url "https://www.jitpack.io" }
}

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath "org.jooq:jooq:3.17.0" // older version due to older MySQL version on the host
        classpath "org.jooq:jooq-codegen:3.17.0"
        classpath "org.jooq:jooq-meta:3.17.0"
        classpath "org.postgresql:postgresql:42.7.3"
    }
}

dependencies {
    annotationProcessor "org.projectlombok:lombok:$lombokVersion"
    compileOnly "org.projectlombok:lombok:$lombokVersion"

    /*compileOnly("com.github.Anuken.MindustryJitpack:core:$mindustryVersion") {
        exclude module: "flabel"
        exclude module: "arcnet"
        exclude module: "g3d"
        exclude module: "freetype"
        exclude module: "fx"
    }*/
    compileOnly "com.github.Anuken.Arc:arc-core:$mindustryVersion"

    implementation "org.jooq:jooq:$jooqVersion"
    runtimeOnly "org.postgresql:postgresql:$postresqlVersion"
    implementation "com.zaxxer:HikariCP:$hikariVersion"

    implementation "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion"

    implementation "org.jetbrains:annotations:16.0.1"
}

publishing {
    publications {
        maven(MavenPublication) {
            from components.java
        }
    }
}

task codegen {
    doLast {
        def host, schema, user, password
        if (!project.hasProperty("dbhost") || !project.hasProperty("dbschema") || !project.hasProperty("dbuser") || !project.hasProperty("dbpassword")) {
            if (file("./database.json").exists()) {
                println("Using local JSON config")
                def json = new JsonSlurper()
                def dbFile = file("./database.json")
                def db = json.parseText(dbFile.text)

                host = db.host
                schema = db.schema
                user = db.username
                password = db.password
            } else {
                println("\u001B[33;1mWARNING!\u001B[0m No DB config. Compiling may fail due to lack of `gen` packet")
                return
            }
        } else {
            host = project.property("dbhost")
            schema = project.property("dbschema")
            user = project.property("dbuser")
            password = project.property("dbpassword")
        }
        println(sourceSets.main.java.srcDirs.first().path)
        Configuration configuration = new Configuration()
                .withJdbc(new Jdbc()
                        .withDriver("org.postgresql.Driver")
                        .withUrl("jdbc:postgresql://$host:5432/$schema")
                        .withUser("$user")
                        .withPassword("$password")
                )
                .withGenerator(new Generator()
                        .withDatabase(new Database()
                                .withName("org.jooq.meta.postgres.PostgresDatabase")
                                .withIncludes(".*")
                                .withExcludes("")
                                .withInputSchema("${schema}")
                                .withForcedTypes(
                                        new ForcedType()
                                                .withUserType("stellar.database.enums.MessageType")
                                                .withEnumConverter(true)
                                                .withIncludeExpression("mindustry\\.messages\\.type"),
                                        new ForcedType()
                                                .withUserType("stellar.database.enums.PlayerStatus")
                                                .withEnumConverter(true)
                                                .withIncludeExpression("mindustry\\.users\\.status"),
                                        new ForcedType()
                                                .withUserType("stellar.database.enums.PvpMode")
                                                .withEnumConverter(true)
                                                .withIncludeExpression("mindustry\\.matches\\.mode"),
                                        new ForcedType()
                                                .withUserType("java.util.List<stellar.database.types.UnitSnapshot>")
                                                .withConverter("stellar.database.converters.UnitSnapshotConverter")
                                                .withIncludeExpression("mindustry\\.hex_snapshots\\.units")
                                )
                        )
                        .withTarget(new Target()
                                .withPackageName("stellar.database.gen")
                                .withDirectory(sourceSets.main.java.srcDirs.first().path)
                        )
                        .withStrategy(new Strategy()
                                .withName(CamelCaseGeneratorStrategy.name)
                        )
                        .withGenerate(new Generate()
                                .withFluentSetters(true)
                        )
                )

        GenerationTool.generate(configuration)
    }
}

javadoc {
    options.links "https://www.jooq.org/javadoc/3.17.0/"
    destinationDir = file("${buildDir}/docs/javadoc")
}

jar {
    println("Make sure you are using the latest database version. Do `./gradle codegen` to generate code")
    duplicatesStrategy = DuplicatesStrategy.INCLUDE
    archiveFileName = "${project.archivesBaseName}.jar"
    from {
        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
    }
}

processResources {
    def build = (project.hasProperty("buildVersion") ? project.property("buildVersion") : "snapshot")
    println("Compiling with build: '$version $build - $getGitHash'")

    filesMatching("**/version.properties") {
        from it.file
        filter { line -> line.replace("%verType%", build).replace("%verNum%", version).replace("%gitHash%", getGitHash()) }
    }
}

class CamelCaseGeneratorStrategy extends DefaultGeneratorStrategy {
    String getJavaIdentifier(Definition definition) {
        StringUtils.toCamelCaseLC(super.getJavaIdentifier(definition))
    }

    String getJavaGetterName(Definition definition, Mode mode) {
        if (mode == Mode.RECORD) {
            if (((DefaultDataTypeDefinition) definition.getProperties().get("definedType")).type.equalsIgnoreCase("boolean")) {
                return "is" + StringUtils.toCamelCase(definition.getOutputName())
            }
        }
        return "get" + StringUtils.toCamelCase(definition.getOutputName())
    }
}