build.gradle

project.version = getVersion()
println "Building version ${project.version}"

allprojects {
    repositories {
        mavenCentral()
        mavenLocal()
    }
}

buildscript {
    repositories {
        maven {
            setUrl("https://plugins.gradle.org/m2/")
        }
    }
    dependencies {
      classpath 'org.openjfx:javafx-plugin:0.0.13'
      classpath 'com.github.ben-manes:gradle-versions-plugin:0.46.0'
    }
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'jacoco'

    apply plugin: 'idea'
    apply plugin: 'com.github.ben-manes.versions'

    group = 'se.llbit'
    version = rootProject.version

    java {
        toolchain {
            // default java version for the project, some subprojects are pinned to java 8 for backwards compatibility (see their configs).
            languageVersion = JavaLanguageVersion.of(17)
        }
    }
    compileTestJava {
        // compile tests using more recent features
        javaCompiler = javaToolchains.compilerFor {
            languageVersion = JavaLanguageVersion.of(21)
        }
    }
    test {
        // run tests using more recent features
        javaLauncher = javaToolchains.launcherFor {
            languageVersion = JavaLanguageVersion.of(21)
        }
        useJUnitPlatform()

        // Always run tests, even when nothing changed.
        dependsOn 'cleanTest'

        finalizedBy jacocoTestReport // report is always generated after tests run (it's very cheap)
    }
    jacoco {
        toolVersion = "0.8.11"
    }
    jacocoTestReport {
        dependsOn test // tests are required to run before generating the report
    }

    javadoc {
        options.encoding = 'UTF-8'
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    configurations {
        jsonlib
        nbtlib
        cplib
        toolpanelib
    }

    dependencies {
        jsonlib 'se.llbit:jo-json:1.3.1'
        nbtlib 'se.llbit:jo-nbt:1.3.0'
        cplib 'se.llbit:luxcp:1.0.1'
        toolpanelib 'se.llbit:toolpane:0.1'

        testImplementation("org.assertj:assertj-core:3.25.1")

        testImplementation(platform('org.junit:junit-bom:5.10.2'))
        testImplementation('org.junit.jupiter:junit-jupiter')
        testRuntimeOnly('org.junit.platform:junit-platform-launcher')
    }

    idea {
        module {
            downloadJavadoc = true
            downloadSources = true
        }
    }

    dependencyUpdates.gradleReleaseChannel = "current"

    tasks.named("dependencyUpdates") {
        def isNonStable = { String version ->
            def stableKeyword = ['RELEASE', 'FINAL', 'GA'].any { keyword -> version.toUpperCase().contains(keyword) }
            def regex = /^[0-9,.v-]+(-r)?$/
            return !stableKeyword && !(version ==~ regex)
        }

        rejectVersionIf {
            isNonStable(it.candidate.version)
        }
    }

}

defaultTasks 'release'

task releaseVersion {
  doLast {
    tryCommand([ 'git', 'tag', '-a', "${project.version}", '-m', "Version ${project.version}" ], true)
  }
}

task versionInfo(type: JavaExec) {
    dependsOn 'copyArtifacts'
    outputs.upToDateWhen { false }

    outputs.files file("build/chunky-${project.version}.jar")
    description 'Writes build/chunky-VERSION.jar, latest.json and updates chunky-core-VERSION.jar/version.json'
    classpath = project(':releasetools').sourceSets.main.runtimeClasspath
    mainClass.set('releasetools.ReleaseBuilder')
    args "${project.version}", "release_notes-${project.version}.txt"
}

task release {
    dependsOn 'buildReleaseJar', 'versionInfo'

    def destinationDirectory = file("${buildDir}/release")

    doLast {
        project.delete(destinationDirectory)
        destinationDirectory.mkdirs()
        file("./latest.json").renameTo("${destinationDirectory}/latest.json")
        fileTree(buildDir).matching {
            include "*-${project.version}.*"
        }.each {
            it.renameTo("${destinationDirectory}/${it.name}")
        }
    }
}

task buildReleaseJar(type: Jar) {
    dependsOn ':launcher:assembleDist'
    dependsOn 'versionInfo'

    archiveFileName = "chunky-${project.version}.jar"
    destinationDirectory = file('build/installer')
    manifest {
        attributes('Main-Class': 'se.llbit.chunky.launcher.ChunkyLauncher')
    }

    into('lib') {
        from fileTree('chunky/lib').include('*.jar')
        from file("build/chunky-core-${project.version}.jar")
    }

    from {
        project(':launcher').configurations.archives.allArtifacts.files.collect {
            zipTree(it)
        }
    }

    from file("./latest.json")
    rename "latest.json", "version.json"
}

task copyArtifacts(type: Copy) {
    dependsOn subprojects.jar
    from subprojects.jar
    into buildDir
}

/** Helper function to run a command. Returns the command output if the command succeeded. */
def tryCommand(def command, boolean failOnError = false) {
    def out = new StringBuilder()
    def err = new StringBuilder()
    try {
        def proc = command.execute()
        proc.waitForProcessOutput(out, err)
        if (proc.exitValue()) {
            def msg = "failed to run '${command[0]}' (args: ${command.tail()})\n$err$out"
            if (failOnError) {
                throw new GradleException(msg)
            } else {
                print 'Warning: '
                println msg
            }
            ""
        } else {
            if (err) println "${err}"
            out.toString()
        }
    } catch (IOException e) {
        println "failed to run ${command[0]} (args: ${command.tail()}): $e"
        ""
    }
}

/** Helper function to retrieve the current version string. */
def getVersion() {
    if (project.hasProperty('newVersion')) {
        // Manual version override
        return project.newVersion
    }

    // Prerelease version based on stored version and git history
    def prerelease = "DEV"
    if (project.hasProperty('prereleaseTag')) {
        prerelease = project.prereleaseTag
    }

    // Get the stored major version
    Properties versionProperties = new Properties()
    versionProperties.load(new FileInputStream(file('chunky/src/res/se/llbit/chunky/main/Version.properties')))
    def majorVersion = versionProperties['version']

    def preVersion = "0";
    // Attempt to get Git describe output
    def gitDescribe = tryCommand(['git', 'describe', '--abbrev=7', '--long'])
    if (gitDescribe) {
        def gitMatcher = gitDescribe =~ /^.*?-(\d*)-(g.*)/
        gitMatcher.find()
        if (gitMatcher.groupCount() >= 2) {
            preVersion = gitMatcher.group(1) + "." + gitMatcher.group(2)
        }
    }

    return majorVersion + "-" + prerelease + "." + preVersion
}

task install(dependsOn: ':chunky:publish') {
    doLast {
        copy {
            from file("${project(':chunky').buildDir}/maven/")
            into file("${buildDir}/maven/")
        }

        project.delete(file("${project(':chunky').buildDir}/maven/"))
    }
}

// Includes both main and library documentation:
task docs(type: Javadoc) {
    options.encoding = 'UTF-8'
    options.addStringOption('Xdoclint:none', '-quiet')

    def docProjects = [ ':chunky', ':lib' ]
    source docProjects.collect { project(it).sourceSets.main.allJava }
    classpath = files(docProjects.collect { project(it).sourceSets.main.compileClasspath })
    destinationDir = file("${buildDir}/docs/javadoc")
}

task clean {
    group = "Build"
    doLast {
        delete "./build"
    }
}