build.gradle

import org.jodconverter.Deps
import org.jodconverter.Plugins

// External dependencies for the build script
buildscript {
    repositories {
        mavenCentral()
        maven { url "https://plugins.gradle.org/m2/" }

        //Needed only for SNAPSHOT versions
        //maven { url "http://oss.sonatype.org/content/repositories/snapshots/" }
    }

    dependencies {
        classpath Plugins.coveralls
        classpath Plugins.nebulaIntegTest
        classpath Plugins.nexusStaging
        classpath Plugins.spotless
    }
}

description = '''
    JODConverter automates conversions between office document formats
    using LibreOffice or Apache OpenOffice. It automates all conversions
    supported by the running instance of OpenOffice/LibreOffice.
'''

group = 'org.jodconverter'
version = '4.4.8'

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Properties

ext {
    baselineJavaVersion = JavaVersion.VERSION_1_8
    sourceEncoding = "UTF-8"

    // Set up different sub-project lists for individual configuration
    javaProjects = subprojects.findAll {
        new File(it.projectDir, 'src/main/java').directory
    }
    //releasedProjects = javaProjects.findAll {
    //    !it.name.contains('jodconverter-sample')
    //}
    releasedProjects = javaProjects
    librariesProjects = releasedProjects.findAll {
        !it.name.contains('jodconverter-cli')
    }

    defaultJvmArgs = []
    // "JEP 403: Strongly Encapsulate JDK Internals" causes some tests to
    // fail when they try to access internals (often via mocking libraries).à
    // We use `--add-opens` as a workaround for now.
    if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_16)) {
        defaultJvmArgs.addAll(
                "--add-opens=java.base/java.io=ALL-UNNAMED",
                "--add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED"
        )
    }
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Configuration

// Configuration to apply to all the projects
allprojects {

    group = rootProject.group
    version = rootProject.version

    repositories {
        mavenCentral()
    }
}

// Configure Java projects
configure(javaProjects) {
    //println("Configuring java for ${project.name}")
    apply from: "${rootProject.projectDir}/gradle/java-config.gradle"
}

// Configure Java libraries projects
configure(librariesProjects) {
    //println("Configuring java-library for ${project.name}")
    apply plugin: 'java-library'

    apply from: "${rootProject.projectDir}/gradle/publish-config.gradle"
}

// Distribution configuration
configure(releasedProjects) {

    apply plugin: 'distribution'

    // exclude jodconverter-cli since it has its own distribution configuration
    if (!project.name.contains('jodconverter-cli')) {
        distributions {
            main {
                distributionBaseName = project.name
                contents {
                    from jar, sourcesJar, javadocJar
                }
            }
        }
    }
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project

apply plugin: 'idea'
apply plugin: 'eclipse'
apply plugin: 'jacoco'
apply plugin: 'distribution'
apply plugin: 'com.github.kt3k.coveralls'
apply plugin: 'io.codearte.nexus-staging'

// Configure the distribution task by copying all the distributions of the subprojects to the root project.
project.tasks["distZip"].configure {
    description 'Create full distribution zip'
    group 'Distribution'

    archiveBaseName.set(project.name)

    //from releasedProjects.collect { it.tasks.matching { it.name == 'distZip' || it.name == 'distTar' } }
    from releasedProjects.collect { it.distZip }
}
project.tasks["distZip"].dependsOn releasedProjects*.distZip

nexusStaging {
    username = findProperty('ossrhUsername')
    password = findProperty('ossrhPassword')
}

// Exclude folders from IDEA project
idea {
    module {
        excludeDirs += file('.idea')
    }
}

def librariesSources = librariesProjects.sourceSets.main

tasks.register('javadocAll', Javadoc) {
    description 'Aggregates Javadoc API documentation of all libraries.'
    group 'Documentation'
    dependsOn librariesProjects.build

    source librariesSources.allJava

    destinationDir = file("$buildDir/docs/javadoc")
    classpath = files(librariesSources.compileClasspath)

    options.with {
        windowTitle = "JODConverter API Documentation"
        docTitle = "JODConverter $project.version API Documentation"
        header = "JODConverter $project.version API"
        bottom = 'Copyright &#169; 2022 - present; <a href="https://github.com/jodconverter/jodconverter">JODConverter</a>. All rights reserved.'

        //author = false
        //breakIterator = true
        charSet = 'UTF-8'
        docEncoding = 'UTF-8'
        encoding = 'UTF-8'
        memberLevel = JavadocMemberLevel.PROTECTED
        source = baselineJavaVersion

        links(
                "https://docs.oracle.com/javase/8/docs/api/",
                "https://api.libreoffice.org/docs/java/ref/",
                "https://commons.apache.org/proper/commons-lang/javadocs/api-release/",
                "https://docs.spring.io/spring-boot/docs/${Deps.springBootVersion}/api/"
        )
    }
    options.addBooleanOption('Xdoclint:none')
    //options.addStringOption('Xdoclint:none', '-quiet')

    inputs.files(librariesSources.allSource + librariesSources.compileClasspath)
    outputs.dir destinationDir
}

// Creates an aggregated JaCoCo executionData for all
// the tests (unit tests and integration tests) found
// in sub Java projects 
tasks.register('jacocoMerge', JacocoMerge) {
    description = 'Aggregates JaCoCo test and integration test coverage reports of all projects.'
    group = "Reporting"

    // Gather execution data from all subprojects
    releasedProjects.each { subproject ->
        executionData subproject.tasks.withType(Test)
    }
    doFirst {
        executionData = files(executionData.findAll { it.exists() })
    }
}

// Code coverage report for all the sub (java) projects
tasks.register('jacocoRootReport', JacocoReport) {
    description = 'Generates an aggregate report from all subprojects'
    dependsOn releasedProjects.test, releasedProjects.integrationTest, jacocoMerge

    additionalSourceDirs.setFrom(files(releasedProjects.sourceSets.main.allSource.srcDirs))
    sourceDirectories.setFrom(files(releasedProjects.sourceSets.main.allSource.srcDirs))
    classDirectories.setFrom(files(releasedProjects.sourceSets.main.output))
    executionData jacocoMerge.destinationFile

    reports {
        html.required.set(true) // human readable
        xml.required.set(true) // required by coveralls
    }
}

coveralls {
    sourceDirs = releasedProjects.sourceSets.main.allSource.srcDirs.flatten()
    jacocoReportPath = "${buildDir}/reports/jacoco/jacocoRootReport/jacocoRootReport.xml"
}

//tasks.coveralls {
//    group = 'Coverage reports'
//    description = 'Uploads the aggregated coverage report to Coveralls'
//
//    dependsOn jacocoRootReport
//    onlyIf { System.env.'CI' }
//}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Utilities
tasks.register('printConfigurations') {
    group "Help"
    doLast {

        subprojects.findAll().each { p ->
            println "${p}"
            p.configurations.each { println "  | " + it.name }
            println ""
        }
    }
}