build.gradle

import org.apache.tools.ant.taskdefs.condition.Os

plugins {
    id 'java'
    id 'application'
    id 'com.github.johnrengelman.shadow' version '5.0.0'
    id 'org.frgaal.compiler'

    id 'maven-publish'
    // id 'org.jetbrains.kotlin.jvm' version '1.5.0'
}

group 'YAPION'
def groupID = 'yoyosource'
version 'SNAPSHOT'

Properties versionProperties = new Properties()
if (file("version.properties").exists()) {
    versionProperties.load(file("version.properties").newDataInputStream())
}

ext {
    uberJarName = "${group}-${version}-all.jar"
    jarName = "${group}-${version}.jar"
    libs = "${buildDir}/libs"

    groupName = "${group}"

    major = versionProperties.getProperty("major", "0")
    minor = versionProperties.getProperty("minor", "0")
    patch = versionProperties.getProperty("patch", "0")
    publication = major + "." + minor + "." + patch

    releasePath = "releases/${groupID}/${group}"
}

repositories {
    mavenCentral()
}

targetCompatibility = '1.8'
sourceCompatibility = '15'

compileJava.options.encoding = 'UTF-8'
compileJava {
    options.compilerArgs << '-Xlint:deprecation' << '--enable-preview'
}

compileTestJava.options.encoding = 'UTF-8'
compileTestJava {
    options.compilerArgs << '-Xlint:deprecation' << '--enable-preview'
}

mainClassName = ''

dependencies {
    compileOnly 'org.projectlombok:lombok:1.18.22'
    testCompileOnly 'org.projectlombok:lombok:1.18.22'
    annotationProcessor 'org.projectlombok:lombok:1.18.22'
    testAnnotationProcessor 'org.projectlombok:lombok:1.18.22'

    compileOnly 'org.atteo.classindex:classindex:3.11'
    testCompileOnly 'org.atteo.classindex:classindex:3.11'
    annotationProcessor 'org.atteo.classindex:classindex:3.11'
    testAnnotationProcessor 'org.atteo.classindex:classindex:3.11'

    if (file("./libs/YAPION-SNAPSHOT.jar").exists()) {
        annotationProcessor files("./libs/YAPION-SNAPSHOT.jar")
        testAnnotationProcessor files("./libs/YAPION-SNAPSHOT.jar")
    }

    implementation 'org.objenesis:objenesis:3.2'
    implementation 'eu.infomas:annotation-detector:3.0.5'
    // implementation 'org.kamranzafar:jtar:2.3'
    implementation 'org.slf4j:slf4j-api:2.0.0-alpha1'
    implementation 'org.ow2.asm:asm:9.2'

    testImplementation 'junit:junit:4.13.2'
    testImplementation 'org.hamcrest:hamcrest:2.2'

    testImplementation 'ch.qos.logback:logback-classic:1.3.0-alpha5'
}

processResources {
    from(rootDir) {
        include(['LICENSE'])
        into("")

        includeEmptyDirs = false
    }

    doLast {
        File from = new File("${buildDir}/classes/java/main/META-INF/annotations/yapion.annotations.api.ProcessorImplementation")
        File to = new File("${buildDir}/classes/java/main/META-INF/services/javax.annotation.processing.Processor")
        to.delete()
        to.parentFile.mkdirs()
        to.createNewFile()
        for (String s : from.readLines()) {
            to.append(s + "\n");
        }
    }
}

task compressClassFiles {
    description 'Compress Class Files'
    group "build"
    inputs.dir "${buildDir}/classes/java/main/yapion/serializing/serializer/"
    outputs.files("${buildDir}/resources/main/yapion/serializing/serializer.pack", "${buildDir}/resources/main/yapion/serializing/serializer.pack.meta")

    doLast {
        if (file("${buildDir}/classes/java/main/yapion/serializing/serializer/").exists()) {
            String[] strings = shell("java -cp ${buildDir}/classes/java/main/ yapion/serializing/serializer/SerializerPacker")
            if (strings[2] == '0') {
                print(strings[0])
            } else {
                print(strings[0])
                print(strings[1])
            }
            file("${buildDir}/classes/java/main/yapion/serializing/serializer.pack").renameTo(file("${buildDir}/resources/main/yapion/serializing/serializer.pack"))
            file("${buildDir}/classes/java/main/yapion/serializing/serializer.pack.meta").renameTo(file("${buildDir}/resources/main/yapion/serializing/serializer.pack.meta"))
        }
    }
}
classes.finalizedBy(compressClassFiles)

shadowJar {
    manifest {
        attributes(
                'Main-Class': mainClassName
        )
    }
    exclude 'yapion/utils/Packer.class'
    exclude 'yapion/serializing/serializer/**'
    exclude 'META-INF/annotations/**'
}

sourceSets {
    main {
        java {
            srcDirs = ['src/main/java']
            exclude 'test/**', '**/*.kt'
        }
        resources {
            exclude '**/*.ebnf', '**/*.xhtml', "**/*.gitkeep"
        }
    }
    test {
        java {
            srcDirs = ['src/test/java/']
        }
        resources {
            exclude '**/*.ebnf', '**/*.xhtml', "**/*.gitkeep"
        }
    }
}

javadoc {
    source = 'src/main/java/yapion'
    // destinationDir = ''
    include("**/*.java")
    exclude("**/PublicKeySerializer.java")
    exclude("src/main/java/system",
            "src/main/java/test")
}

publishing {
    repositories {
        maven {
            url = "${rootDir}/releases"
        }
    }
    publications {
        maven(MavenPublication) {
            groupId = groupID
            artifactId = group
            version = publication

            from components.java
        }
    }
}

// + "-SNAPSHOT"

task incrementMajor {
    description 'Increment Major'
    group "Release"

    doLast {
        major = Integer.parseInt(major) + 1
        minor = 0
        patch = 0
        println("Version: " + major + "." + minor + "." + patch)
        save()
        println("NEXT STEP: projectPublish")
    }
}

task incrementMinor {
    description 'Increment Minor'
    group "Release"

    doLast {
        minor = Integer.parseInt(minor) + 1
        patch = 0
        println("Version: " + major + "." + minor + "." + patch)
        save()
        println("NEXT STEP: projectPublish")
    }
}

task incrementPatch {
    description 'Increment Patch'
    group "Release"

    doLast {
        patch = Integer.parseInt(patch) + 1
        println("Version: " + major + "." + minor + "." + patch)
        save()
        println("NEXT STEP: projectPublish")
    }
}

private void save() {
    File f = new File("${new File("${buildDir}").parentFile.toString()}/version.properties")
    String[] strings = f.getText().split("\n")
    for (int i = 0; i < strings.length; i++) {
        if (strings[i].startsWith("major = ")) {
            strings[i] = "major = " + major
        } else if (strings[i].startsWith("minor = ")) {
            strings[i] = "minor = " + minor
        } else if (strings[i].startsWith("patch = ")) {
            strings[i] = "patch = " + patch
        }
    }
    f.text = String.join("\n", strings)
}

task projectPublish {
    description 'Publish this repo to GitHub Maven'
    group "Release"

    dependsOn publishMavenPublicationToMavenRepository

    doLast {
        println("NEXT STEP: projectCommit")
    }
}

task projectCommit {
    description 'Commit this repo to GitHub/origin'
    group "Release"

    doLast {
        def status = shell("git status")
        if (!status.toString().contains("${releasePath}/${major}.${minor}.${patch}/")) {
            println("No new Version detected")
            return
        }

        println("Adding new files to git")
        shell("git add ${releasePath}/${major}.${minor}.${patch}/")
        shell("git add gradle.properties")
        shell("git add ${releasePath}/maven-metadata.xml")
        shell("git add ${releasePath}/maven-metadata.xml.md5")
        shell("git add ${releasePath}/maven-metadata.xml.sha1")
        shell("git add ${releasePath}/maven-metadata.xml.sha256")
        shell("git add ${releasePath}/maven-metadata.xml.sha512")

        println("Creating new commit with name 'Maven Release ${major}.${minor}.${patch}'")
        shell("git commit -m \"Maven Release ${major}.${minor}.${patch}\"")
        println("Creating new tag with name 'V${major}.${minor}.${patch}'")
        shell("git tag \"V${major}.${minor}.${patch}\"")

        if (!answer("Should this commit be pushed? [Y/n]")) {
            println("Use 'git push' and 'git push --tags' to manually push this to origin.")
        } else {
            shell("git push")
            shell("git push --tags")
        }

        println("NEXT STEP: projectJavaDoc")
    }
}

task projectJavaDoc {
    description 'Create new JavaDoc for the existing sources'
    group "Release"

    dependsOn javadoc

    doLast {
        shell("mkdir docs/javadoc/v${major}.${minor}.${patch}")
        shell("cp -R build/docs/javadoc/* docs/javadoc/v${major}.${minor}.${patch}")

        if (!answer("Should this change be comitted? [Y/n]")) {
            println("Use 'git commit -m \"Documentation update\"' to manually commit this change.'")
            return
        }
        println("Creating new commit with name 'Documentation update'")
        shell("git add docs/javadoc/v${major}.${minor}.${patch}")
        shell("git commit -m \"Documentation update\"")

        if (answer("Should this commit be pushed? [Y/n]")) {
            shell("git push")
        } else {
            println("Use 'git push' to manually push this to origin.")
        }

        println("NEXT STEP: ----")
    }
}

def deleteDirRecursively(String dir) {
    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        dir = dir.replace('/', '\\')
        if (new File(dir).isDirectory()) {
            return shell("rmdir /s /q ${dir}")
        } else {
            return shell("del /F /S /Q /A ${dir}")
        }
    } else {
        return shell("rm -r ${dir}")
    }
}

/**
 * Executes a shell command and returns the stdout result.
 *
 * @param command the command to execute (cannot contain pipes)
 * @return the trimmed result from stdout, stderr and the exit value
 */
def shell(String command) {
    def proc
    if (!Os.isFamily(Os.FAMILY_WINDOWS)) {
        proc = ['bash', '-c', command].execute()
    } else {
        proc = ["cmd", "/c", command].execute()
    }
    def out = new StringBuilder()
    def err = new StringBuilder()
    proc.waitForProcessOutput(out, err)
    return [out.toString().trim(), err.toString().trim(), proc.exitValue()]
}

def answer(String question) {
    while (System.in.available() > 0) System.in.read()
    println(question)
    return "Yy".contains(((char) System.in.read()).toString())
}

task buildProject {
    description 'Build this repo'
    group "Build"

    doLast {
        if ("${buildDir}" == null) {
            return
        }
        delete fileTree("${libs}").matching {
            exclude("${uberJarName}")
        }
        file(libs + "/" + uberJarName).renameTo(file(libs + "/" + jarName))

        long size = file(libs + "/" + jarName).size()
        println("Size: " + (size / 1024.0) + "kB")
    }
}
build.finalizedBy(buildProject)
assemble.finalizedBy(buildProject)

task testOutput {
    description 'Print Test output'
    group "Build"

    doLast {
        for (def file : new File("${buildDir}/test-results/test/").listFiles()) {
            if (file.isDirectory()) {
                continue
            }
            def strings = file.readLines()
            if (strings.get(1).contains("failures=\"0\"")) {
                continue
            }
            println "Content ${file}:"
            strings.each {
                line -> println ": $line"
            }
            println ""
        }
    }
}
test.finalizedBy(testOutput)