build.gradle

/*   __    __         _
 *   \ \  / /__ _ __ (_) ___ ___
 *    \ \/ / _ \ '_ \| |/ __/ _ \
 *     \  /  __/ | | | | (_|  __/
 *      \/ \___|_| |_|_|\___\___|
 *
 *
 * Copyright 2017-2024 Venice
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// -----------------------------------------------------------------------------
// Gradle build
// -----------------------------------------------------------------------------
//
// Venice uses Gradle 8.0
//
// JPMS (Java Platform Module System)
//
//   The Venice Gradle build is prepared to support building a Java 8 library
//   for JPMS. The 'compileModuleInfoJava' task provides a Java 9 compiled
//   'module-info.class' in the root output directory.
//   See also: https://dzone.com/articles/building-java-6-8-libraries-for-jpms-in-gradle
//
//
// Build commands
//
//   - Build the Venice jar
//     $> ./gradlew shadowJar
//     $> ./gradlew --warning-mode all clean shadowJar
//
//   - Build the Venice cheatsheet (HTML & PDF)
//     $> ./gradlew clean cheatsheet
//
//   - Run the unit tests
//     $> ./gradlew clean test
//
//   - Micro benchmarks
//     $> ./gradlew jmh -Pinclude=".*PrecompileBenchmark"
//     $> ./gradlew -Dorg.gradle.java.home=${JAVA_11_ZULU_HOME}
//                  jmh
//                  -Pinclude=".*PrecompileBenchmark"
//                  -PjvmArgs="-XX:+UseParallelGC"
//     $> ./gradlew jmh
//                  -Pinclude=".*PrecompileBenchmark"
//                  -PjvmArgs="-XX:+PrintCompilation -XX:CompileThreshold=1000"
//
//
// Dependency list
//
//     $> ./gradlew dependencies
//
// -----------------------------------------------------------------------------
// Release Venice:
//
//   [1] Prepare Venice
//       - Verify that all unit tests pass: ./gradlew clean test
//       - Change version in 'gradle.properties' to '1.x.y' (remove the
//         SNAPSHOT suffix)
//       - Update the ChangeLog for the release version
//       - Update files with release version: ./gradlew updateReleaseVersion
//       - Generate cheatsheets: ./gradlew cheatsheet
//       - Commit the changes with message "bumped to new version"
//       - Update the Git commit Id in the cheatsheet URLs in 'README.md':
//           ./gradlew updateReadMeCheatsheetRef
//       - Commit the 'README.md' change
//
//   [2] Publish to Maven
//       - see example https://github.com/kit-data-manager/nexus-publish-example
//       - ./gradlew -Dorg.gradle.internal.publish.checksums.insecure=true
//                   -Dorg.gradle.internal.http.socketTimeout=60000
//                   -Dorg.gradle.internal.http.connectionTimeout=60000
//                   --warning-mode all
//                   -Psigning.gnupg.keyName=[gpg-user-key-id]
//                   -PsonatypeUsername=[name]
//                   -PsonatypePassword=[pw]
//                   clean shadowJar publish
//         see:  https://central.sonatype.org/news/20240301_changes_to_account_management/
//       - Log in to Sonatype OSSRH (https://oss.sonatype.org/)
//       - Choose Staging Repositories
//       - Find the release 'comgithubjlangch-*'
//       - Verify the contents are ok
//       - Click Close (wait for validation steps under the Activity tab
//         to complete)
//       - Click Release
//
//   [3] Draft a GitHub Venice release
//       - Draft a new release in Git (https://github.com/jlangch/venice/releases)
//         This will create the release tag
//       - Pull the changes (commit tag)
//
//   [4] Open new development cycle
//       - Change version in 'gradle.properties' to '1.x.y-SNAPSHOT'
//       - Add an empty ChangeLog entry for the new version
//       - Commit with message "opened new dev cycle"
//
// -----------------------------------------------------------------------------
// Gradle wrapper
//
//    Upgrade Gradle wrapper:
//      See https://docs.gradle.org/current/userguide/gradle_wrapper.html
//      Upgrade:
//         $> ./gradlew wrapper --gradle-version=8.3 --distribution-type=bin
//
//    Get initial Gradle wrapper
//      See https://guides.gradle.org/creating-new-gradle-builds/
//
//    Create and init a gradle project:
//       $> mkdir test
//       $> cd test
//       $> gradle init
//
// -----------------------------------------------------------------------------
//
// Git is not working after macOS Update (xcrun: error: invalid active developer 
// path (/Library/Developer/CommandLineTools). 
//
// See: https://stackoverflow.com/questions/52522565/git-is-not-working-after-macos-update-xcrun-error-invalid-active-developer-pa
//      https://stackoverflow.com/questions/32893412/command-line-tools-not-working-os-x-el-capitan-sierra-high-sierra-mojave/32894314#32894314
//
// -----------------------------------------------------------------------------
// Gradle project configuration for Eclipse IDE
//
//    Requires the plugin 'eclipse' in the build.gradle
//
//    1.  Project checkout
//    2.  Move to your projects path (where gradle or gradlew is found)
//    3.  Unix: ./gradlew cleaneclipse
//        Win:  gradlew cleaneclipse
//    4.  Refresh your Project in Eclipse
//    5.  After that for Unix: ./gradlew eclipse
//                       Win:  gradlew eclipse
//    6.  Refresh your Project in Eclipse
//
//    Repeat step 5) and 6) whenever the Gradle build 
//
//    Under the "Build Path" -> "Libraries" tab, click "Add Library", "JUnit",  
//    "Next", select "JUnit 5", and click "Finish" this will add
//       <classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
//    to the .classpath file 
//
// -----------------------------------------------------------------------------
// GPG Tools for publishing
//
//   Download:       https://gpgtools.org/
//
//   Migrate Keys:   https://access.redhat.com/solutions/2115511
//
// -----------------------------------------------------------------------------

plugins {
    id 'java'
    id 'maven-publish'
    id 'signing'
    id 'eclipse'

    // https://github.com/johnrengelman/shadow/
    // note: the shadow plugin does not work for jline3 3.22.0+
    //       jline3 3.22.0+ has a new service file structure under META-INF/services
    id 'com.github.johnrengelman.shadow' version '8.1.1'

/*
    // https://github.com/kordamp/jdeps-gradle-plugin
    id 'org.kordamp.gradle.jdeps' version '0.16.0'

    // https://github.com/kordamp/jdeprscan-gradle-plugin
    id 'org.kordamp.gradle.jdeprscan' version '0.10.0'
*/
}


ext {
    bouncyCastle_Version = '1.77'
    commonsIo_Version = '2.11.0'
    docx4j_Version_Java8 = '8.3.4'
    docx4j_Version_Java11 = '11.4.5'
    docxStamper_Version = '1.4.0'
    flyingSaucer_Version = '9.4.0'
    javassist_Version = '3.28.0-GA'
    jaxb_Version = '2.3.1'
    jmh_Version = '1.32'
    jansi_Version = '2.4.1'
    jline_Version = '3.21.0'
    jupiter_Version = '5.8.2'
    openpdf_Version = '1.3.35'
    pdfbox_Version = '3.0.1'
    jbig2_imageio_Version = '3.0.4'
    poi_Version = '5.2.3' // '4.1.2'
    servletApi_Version = '5.0.0'
    springExpression_Version = '5.2.0.RELEASE'
    vavr_Version = '0.10.4'
    xchart_Version = '3.8.6'
    zip4j_Version = '2.11.5'
}


def group = 'com.github.jlangch'

def version_regex = '[0-9]+[.][0-9]+[.][0-9]+(-SNAPSHOT)?'

def sonatypeUsername = project.properties['sonatypeUsername'] ?: "unknown"
def sonatypePassword = project.properties['sonatypePassword'] ?: "unknown"

// Detect Java 8 or 11+
def javaCurr = JavaVersion.current()
def javaVendor = System.getProperty("java.vendor")
def java8 = JavaVersion.current() == JavaVersion.VERSION_1_8
def java11 = JavaVersion.current() >= JavaVersion.VERSION_11
println "Gradle running on Java    : ${javaCurr} (${javaVendor})"
println "Gradle running on Java 8  : ${java8}"
println "Gradle running on Java 11+: ${java11}"

def getCheckedOutGitCommitHash() {
    def takeFromHash = 12

    try {
        def process = 'git rev-parse --verify --short HEAD'.execute()
        if (process.exitValue() == 0) {
            return process.text
                          .trim()
                          .take(takeFromHash)
        }
        else {
            throw new Exception()
        }
    }
    catch(Exception e) {
        println "getCheckedOutGitCommitId(): 'git' not installed, falling back to '.git' folder ..."

        def gitFolder = "$projectDir/.git/"
        /*
         * '.git/HEAD' contains either
         *      in case of detached head: the currently checked out commit hash
         *      otherwise: a reference to a file containing the current commit hash
         */
        def head = new File(gitFolder + "HEAD").text.split(":") // .git/HEAD
        def isCommit = head.length == 1    // e5a7c79edabbf7dd39888442df081b1c9d8e88fd
        // def isRef = head.length > 1     // ref: refs/heads/master

        if (isCommit) {
            return head[0].trim().take(takeFromHash) // e5a7c79edabb
        }
        else {
            def refHead = new File(gitFolder + head[1].trim()) // .git/refs/heads/master
            return refHead.text.trim().take(takeFromHash)
        }
    }
}


compileJava {
    sourceCompatibility = 1.8
    targetCompatibility = 1.8
    options.encoding = 'UTF-8'
    options.compilerArgs = [ '-parameters' ]

    doLast {
        println "Java: ${JavaVersion.current()}"
    }
}

compileTestJava {
    sourceCompatibility = 1.8
    targetCompatibility = 1.8
    options.encoding = 'UTF-8'
    options.compilerArgs += [ '-parameters' ]
}

/* JPMS support currently disabled
task compileModuleInfoJava(type: JavaCompile) {
    classpath = files() // empty
    source = 'src/main/java9/module-info.java'
    destinationDir = compileJava.destinationDir // same dir to see classes compiled by compileJava

    doFirst {
        options.compilerArgs = [
           '--release', '9',
           '--module-path', compileJava.classpath.asPath
        ]
    }
}

compileModuleInfoJava.dependsOn compileJava
classes.dependsOn compileModuleInfoJava
*/


repositories {
    mavenCentral()
}


sourceSets {
    jmh {
        java.srcDirs = ['src/jmh/java']
    }

    main {
        java {
            srcDirs = ['src/main/java']
        }
        resources {
            srcDirs = ['src/main/resources',
                       'doc/examples/scripts']
        }
    }

    test {
        java {
            srcDirs = ['src/test/java']
        }
        resources {
            srcDir "src/test/java"
            include "**/*.venice"
        }
    }
}


java {
    withJavadocJar()
    withSourcesJar()
}


javadoc {
    exclude "com/github/jlangch/venice/impl/**"
    exclude "com/github/jlangch/venice/examples/**"
    exclude "com/github/jlangch/venice/nanojson/**"
    source = sourceSets.main.allJava
}


test {
    // prevent unit tests that check exceptions to fail intermittently
    jvmArgs '-XX:-OmitStackTraceInFastThrow'

    useJUnitPlatform {
    }

    testLogging {
        showStandardStreams = false
        
        events "PASSED", "FAILED", "STANDARD_OUT", "STANDARD_ERROR"
	    
        afterSuite { desc, result ->
            if (!desc.parent) { // will match the outermost suite
                def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} passed, ${result.failedTestCount} failed, ${result.skippedTestCount} skipped)"
                def startItem = '|  ', endItem = '  |'
                def repeatLength = startItem.length() + output.length() + endItem.length()
                println('\n' + '+' + ('-' * (repeatLength - 2)) + '+' + 
                        '\n' + startItem + output + endItem + 
                        '\n' + '+' + ('-' * (repeatLength - 2)) + '+')
            }
        }
    }
}


jar {
    exclude 'com/github/jlangch/venice/fonts/OpenSans-*.ttf'
    exclude 'com/github/jlangch/venice/fonts/SourceCodePro-*.ttf'
    exclude 'data'      // doc/examples/scripts/data
    exclude 'nbody'     // doc/examples/scripts/nbody

    archiveFileName = "venice-raw-${project.version}.jar"
}


shadowJar {
    // https://github.com/johnrengelman/shadow/
    // https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Jar.html

    relocate 'io.vavr', 'org.repackage.io.vavr'
    relocate 'org.jline', 'org.repackage.org.jline'
    relocate 'net.lingala.zip4j', 'org.repackage.net.lingala.zip4j'

    def buildTimestamp = new Date().format("yyyy-MM-dd'T'HH:mm:ss")

    manifest {
        attributes 'Main-Class':             'com.github.jlangch.venice.Launcher',
                   'Build-Date':             new Date().format("yyyy-MM-dd'T'HH:mm:ss"),
                   'Implementation-Vendor':  'com.github.jlangch',
                   'Implementation-Title':   'Venice',
                   'Implementation-Version': "${project.version}",
                   'Specification-Vendor':   'com.github.jlangch',
                   'Application-Name':       'Venice'
    }

    exclude 'com/github/jlangch/venice/fonts/OpenSans-*.ttf'
    exclude 'com/github/jlangch/venice/fonts/SourceCodePro-*.ttf'
    exclude 'data'      // doc/examples/scripts/data
    exclude 'nbody'     // doc/examples/scripts/nbody

    mergeServiceFiles()

    archiveFileName = "venice-${project.version}.jar"
    archiveClassifier = ''  // default is '-all'
}


publishing {
    publications {
        venicePublication(MavenPublication) {
            groupId = 'com.github.jlangch'
            artifactId = 'venice'
            version = "${project.version}"

            artifact sourcesJar
            artifact javadocJar
            artifact shadowJar

            versionMapping {
                usage('java-api') {
                    fromResolutionOf('runtimeClasspath')
                }
                usage('java-runtime') {
                    fromResolutionResult()
                }
            }

            pom {
                name = 'Venice'
                description = 'Venice, a sandboxed Lisp implemented in Java.'
                url = 'https://github.com/jlangch/venice/'
                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }
                developers {
                    developer {
                        id = 'jlangch'
                        name = 'Juerg Lang'
                        email = 'juerg.ch@ggaweb.ch'
                    }
                }
                scm {
                    connection = 'scm:git:git@github.com:jlangch/venice.git'
                    developerConnection = 'scm:git:git@github.com:jlangch/venice.git'
                    url = 'http://github.com:jlangch/venice/tree/master'
                    tag = 'HEAD'
                }
            }
        }
    }

    repositories {
        if(!version.endsWith('SNAPSHOT')) {
            maven {
                url "https://oss.sonatype.org/service/local/staging/deploy/maven2"

                credentials {
                    username sonatypeUsername
                    password sonatypePassword
                }
            }
        }
    }
}


signing {
    useGpgCmd()  // use the local GPG agent to sign the artefacts

    sign publishing.publications.venicePublication
}

/*
jdepsReport {
    sourceSets = ['main']
    configurations = ['runtime']
}


jdeprscanReport {
    // requires Java 9+
    sourceSets = ['main']
    configurations = ['runtime']
}
*/

task bundle(type: Exec, dependsOn: [clean, shadowJar, sourcesJar, javadocJar]) {
    workingDir 'build/libs'

    commandLine "/bin/sh",
                "-c",
                "cat ../../src/main/resources/com/github/jlangch/venice/old/pom.xml " +
                  " | sed 's/__VERSION__/${project.version}/g' > ./pom.xml" +
                  "; echo 'Bundling Venice ${project.version}'" +
                  "; echo 'Signing artifacts...'" +
                  "; gpg2 -ab pom.xml" +
                  "; gpg2 -ab venice-${project.version}-javadoc.jar" +
                  "; gpg2 -ab venice-${project.version}-sources.jar" +
                  "; gpg2 -ab venice-${project.version}.jar" +
                  "; echo 'Bundling artifacts...'" +
                  "; jar -cvf bundle.jar" +
                         " pom.xml pom.xml.asc" +
                         " venice-${project.version}-javadoc.jar venice-${project.version}-javadoc.jar.asc" +
                         " venice-${project.version}-sources.jar venice-${project.version}-sources.jar.asc" +
                         " venice-${project.version}.jar venice-${project.version}.jar.asc" +
                  "; echo 'Bundling done.'"
}

task cheatsheet(type: JavaExec, dependsOn: compileJava) {
    description="Generate cheatsheet"

    mainClass = 'com.github.jlangch.venice.CheatsheetDocGen'

    classpath {
      [ sourceSets.main.runtimeClasspath,
        sourceSets.main.compileClasspath,
        "src/main/resources" ]
    }

    args "${project.version}"
}


task updateReleaseVersion {
    doLast {
        if(version.endsWith('SNAPSHOT')) {
            throw new GradleException(
                    "Rejected updating release version. ${project.version} is not a release!")
        }

        println "Updating version ${project.version} -> 'maven-central.svg'"
        ant.replaceregexp(
                match:   "v${version_regex}",
                replace: "v${project.version}",
                flags:   'g'
        ) {
            fileset(dir: 'doc', includes: 'maven-central.svg')
        }

        println "Updating version ${project.version} -> 'build-dependencies.md'"
        ant.replaceregexp(
                match:   "${version_regex}",
                replace: "${project.version}",
                flags:   'g'
        ) {
            fileset(dir: 'doc/readme', includes: 'build-dependencies.md')
        }

        println "Updating version ${project.version} -> 'notice.txt', 'license.txt'"
        ant.replaceregexp(
                match:   "Venice Release ${version_regex}",
                replace: "Venice Release ${project.version}",
                flags:   'g'
        ) {
            fileset(dir: 'src/main/resources/META-INF', includes: 'notice.txt')
            fileset(dir: 'src/main/resources/META-INF', includes: 'license.txt')
        }

        println "Updating version ${project.version} -> 'app.venice'"
        ant.replaceregexp(
                match:   "venice-${version_regex}[.]jar",
                replace: "venice-${project.version}.jar",
                flags:   'g'
        ) {
            fileset(dir: 'src/main/resources', includes: '**/app.venice')
        }

        println "Updating version ${project.version} -> 'readme/*.md'"
        ant.replaceregexp(
                match:   "venice-${version_regex}[.]jar",
                replace: "venice-${project.version}.jar",
                flags:   'g'
        ) {
            fileset(dir: 'doc/readme', includes: '*.md')
        }
        ant.replaceregexp(
                match:   "V${version_regex}",
                replace: "V${project.version}",
                flags:   'g'
        ) {
            fileset(dir: 'doc/readme', includes: 'start.md')
        }
        ant.replaceregexp(
                match:   "/venice/${version_regex}/",
                replace: "/venice/${project.version}/",
                flags:   'g'
        ) {
            fileset(dir: 'doc/readme', includes: 'start.md')
        }
        ant.replaceregexp(
                match:   "venice-${version_regex}[.]jar",
                replace: "venice-${project.version}.jar",
                flags:   'g'
        ) {
            fileset(dir: 'doc/readme', includes: 'start.md')
        }

        println "Updating version ${project.version} -> 'Launcher.java'"
        ant.replaceregexp(
                match:   "venice-${version_regex}[.]jar",
                replace: "venice-${project.version}.jar",
                flags:   'g'
        ) {
            fileset(dir: 'src/main/java', includes: 'com/github/jlangch/venice/Launcher.java')
        }

        println "Updating version ${project.version} -> 'repl.sh', 'repl.bat'"
        ant.replaceregexp(
                match:   "venice-${version_regex}[.]jar",
                replace: "venice-${project.version}.jar",
                flags:   'g'
        ) {
            fileset(dir: 'src/main/resources', includes: '**/repl.sh')
            fileset(dir: 'src/main/resources', includes: '**/repl.bat')
            fileset(dir: 'doc/examples', includes: 'repl.sh')
            fileset(dir: 'doc/examples', includes: 'repl.bat')
        }
    }
}

task updateReadMeCheatsheetRef {
    doLast {
        def id = getCheckedOutGitCommitHash().take(7)
        println "Updating Cheatsheet id ${id} -> 'README.md'"
        ant.replaceregexp(
                match:   "jlangch/venice/[0-9a-f]{7}/cheatsheet",
                replace: "jlangch/venice/${id}/cheatsheet",
                flags:   'g'
        ) {
            fileset(dir: '.', includes: 'README.md')
        }
    }
}


task ('jmhHelp', description:'Print help for the jmh task') {
    doLast {
        println ""
        println "Usage of jmh tasks:"
        println ""

        println "Only execute specific benchmark(s):"
        println "\t./gradlew jmh -Pinclude=\".*MyBenchmark.*\""

        println ""
        println "Specify extra profilers:"
        println "\t./gradlew jmh -Pprofilers=\"gc,stack\""

        println ""
        println "Prominent profilers (for full list call jmhProfilers task):"
        println "\tcomp - JitCompilations, tune your iterations"
        println "\tstack - which methods used most time"
        println "\tgc - print garbage collection stats"
        println "\ths_thr - thread usage"

        println ""
        println "Change report format from JSON to one of [CSV, JSON, NONE, SCSV, TEXT]:"
        println "\t./gradlew jmh -Pformat=csv"

        println ""
        println "Specify JVM arguments:"
        println "\t./gradlew jmh -PjvmArgs=\"-Dtest.cluster=local\""

        println ""
        println "Run in verification mode (execute benchmarks with minimum of fork/warmup-/benchmark-iterations):"
        println "\tgw jmh -Pverify"

        println ""
        println "Resources:"
        println "\thttp://tutorials.jenkov.com/java-performance/jmh.html (Introduction)"
        println "\thttp://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/ (Samples)"
    }
}


task jmhProfilers(type: JavaExec, description:'Lists the available profilers for the jmh task', group: 'Development') {
    classpath = sourceSets.jmh.runtimeClasspath
    mainClass = 'org.openjdk.jmh.Main'
    args '-lprof'
}


task jmh(type: JavaExec, description: 'Executing JMH benchmarks') {
    classpath = sourceSets.jmh.runtimeClasspath
    mainClass = 'org.openjdk.jmh.Main'

    def include = project.properties.get('include', '');
    def exclude = project.properties.get('exclude');
    def format = project.properties.get('format', 'json');
    def profilers = project.properties.get('profilers');
    def jvmArgs = project.properties.get('jvmArgs')
    def verify =  project.properties.get('verify');

    def resultFile = file("build/reports/jmh/result.${format}")

    args include
    if (exclude) {
        args '-e', exclude
    }
    if (verify != null) { // execute benchmarks with the minimum amount of execution (only to check if they are working)
        println ">> Running in verify mode"
        args '-f' , 1
        args '-wi' , 1
        args '-i' , 1
    }
    args '-foe', 'true'   //fail-on-error
    args '-v', 'NORMAL'   //verbosity [SILENT, NORMAL, EXTRA]
    if (profilers) {
        profilers.split(',').each {
            args '-prof', it
        }
    }
    args '-jvmArgsPrepend', '-Xmx3072m'
    args '-jvmArgsPrepend', '-Xms3072m'
    if (jvmArgs) {
        for (jvmArg in jvmArgs.split(' ')) {
            args '-jvmArgsPrepend', jvmArg
        }
    }
    args '-rf', format
    args '-rff', resultFile

    doFirst {
        println "\nExecuting JMH with: $args \n"
        resultFile.parentFile.mkdirs()
    }
}


artifacts {
    archives sourcesJar
    archives javadocJar
}


dependencies {
    // JMH (the Java Microbenchmark Harness) has been added to the JDK
    // starting with JDK 12; for earlier versions, the dependencies
    // have to be added explicitly.
    // See: https://gitlab.com/barfuin/jmh-gradle-example
    jmhImplementation project
    jmhImplementation "io.vavr:vavr:${vavr_Version}"
    jmhImplementation "org.openjdk.jmh:jmh-core:${jmh_Version}"
    jmhAnnotationProcessor "org.openjdk.jmh:jmh-generator-annprocess:${jmh_Version}"

    compileOnly "org.openjdk.jmh:jmh-core:${jmh_Version}"
    compileOnly "org.openjdk.jmh:jmh-generator-annprocess:${jmh_Version}"
    compileOnly "org.fusesource.jansi:jansi:${jansi_Version}"

 
    // Unit tests
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
    
    testImplementation "org.junit.jupiter:junit-jupiter-api:${jupiter_Version}"
    testImplementation "org.junit.jupiter:junit-jupiter-engine:${jupiter_Version}"
    testImplementation "org.xhtmlrenderer:flying-saucer-core:${flyingSaucer_Version}"
    testImplementation "org.xhtmlrenderer:flying-saucer-pdf:${flyingSaucer_Version}"
    testImplementation "com.github.librepdf:openpdf:${openpdf_Version}"
    testImplementation "com.github.librepdf:pdf-toolbox:${openpdf_Version}"
    testImplementation "com.github.librepdf:openpdf-fonts-extra:${openpdf_Version}"
    testImplementation "org.knowm.xchart:xchart:${xchart_Version}"
    testImplementation "org.apache.poi:poi:${poi_Version}"
    testImplementation "org.apache.poi:poi-ooxml:${poi_Version}"
    
    testImplementation "org.bouncycastle:bcprov-jdk18on:${bouncyCastle_Version}"
    testImplementation "org.bouncycastle:bcprov-ext-jdk15to18:${bouncyCastle_Version}"
    testImplementation "org.bouncycastle:bcutil-jdk18on:${bouncyCastle_Version}"
    testImplementation "org.bouncycastle:bcpkix-jdk18on:${bouncyCastle_Version}"
    testImplementation "org.bouncycastle:bctls-jdk18on:${bouncyCastle_Version}" 


    // Cheatsheet generation
    compileOnly "org.xhtmlrenderer:flying-saucer-core:${flyingSaucer_Version}"
    compileOnly "org.xhtmlrenderer:flying-saucer-pdf:${flyingSaucer_Version}"
    compileOnly "com.github.librepdf:openpdf:${openpdf_Version}"
    compileOnly "com.github.librepdf:pdf-toolbox:${openpdf_Version}"
    compileOnly "com.github.librepdf:openpdf-fonts-extra:${openpdf_Version}"
    compileOnly "org.knowm.xchart:xchart:${xchart_Version}"
    
    // PDF text extractor
    compileOnly "org.apache.pdfbox:pdfbox:${pdfbox_Version}"
    compileOnly "org.apache.pdfbox:pdfbox-io:${pdfbox_Version}"
    compileOnly "org.apache.pdfbox:fontbox:${pdfbox_Version}"
    compileOnly "org.apache.pdfbox:jbig2-imageio:${jbig2_imageio_Version}"
   
    // MS Excel support
    compileOnly "org.apache.poi:poi:${poi_Version}"
    compileOnly "org.apache.poi:poi-ooxml:${poi_Version}"
    // compileOnly "org.apache.poi:poi-ooxml-schemas:${poi_Version}" // only for POI 4.x

    // MS Word support
    compileOnly "org.wickedsource.docx-stamper:docx-stamper:${docxStamper_Version}"
    compileOnly "commons-io:commons-io:${commonsIo_Version}"
    compileOnly "org.javassist:javassist:${javassist_Version}"
    compileOnly "org.springframework:spring-expression:${springExpression_Version}"
    if (java8) {
        compileOnly "org.docx4j:docx4j-core:${docx4j_Version_Java8}"   // Java 8
    }
    else {
        compileOnly "org.docx4j:docx4j-core:${docx4j_Version_Java11}"  // Java 11+
        compileOnly "javax.xml.bind:jaxb-api:${jaxb_Version}"          // Java 11+
    }

    // WebApp support
    compileOnly "jakarta.servlet:jakarta.servlet-api:${servletApi_Version}"

    // Bouncy Castle
    compileOnly "org.bouncycastle:bcprov-jdk18on:${bouncyCastle_Version}"
    compileOnly "org.bouncycastle:bcprov-ext-jdk15to18:${bouncyCastle_Version}"
    compileOnly "org.bouncycastle:bcutil-jdk18on:${bouncyCastle_Version}"
    compileOnly "org.bouncycastle:bcpkix-jdk18on:${bouncyCastle_Version}"
    compileOnly "org.bouncycastle:bctls-jdk18on:${bouncyCastle_Version}" 

    // runtime dependencies (repackaged)
    implementation "io.vavr:vavr:${vavr_Version}"
    implementation "org.jline:jline:${jline_Version}"
    implementation "net.lingala.zip4j:zip4j:${zip4j_Version}"
}