jacoco.gradle

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 Piasy
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/**
 *  Apply additional build steps to sub-projects
 */
subprojects { prj ->

    // Apply Jacoco only if the project is not in the ignore list
    logger.debug("subprojects: " + prj.name)
    if (!rootProject.ext.ignoredByJacoco.contains(prj.name)) {
        apply plugin: 'jacoco'

        jacoco {
            version rootProject.ext.jacocoVersion
        }

        task jacocoReport(type: JacocoReport, dependsOn: 'test') {
            group = 'Reporting'
            description = 'Generate Jacoco coverage reports after running tests.'

            reports {
                xml.enabled = true
                html.enabled = true
            }

            classDirectories = fileTree(
                    dir: rootProject.ext.moduleClassDirs[prj.name]
            )

            afterEvaluate {
                classDirectories = files(classDirectories.files.collect {
                    fileTree(dir: it, exclude: rootProject.ext.moduleExcludes[prj.name])
                })
            }

            sourceDirectories = files('src/main/java')
            executionData = files(rootProject.ext.moduleJacocoExec[prj.name])

            doFirst {
                renameClasses(prj.name + File.separator + rootProject.ext.moduleClassDirs[prj.name])
            }
        }
    }
}

apply plugin: 'jacoco'

jacoco {
    toolVersion rootProject.ext.jacocoVersion
}

/**
 *  Root task that generates an aggregated Jacoco test coverage report for all sub-projects
 */
task jacocoFullReport(type: JacocoReport, group: 'Coverage reports') {
    group = 'Reporting'
    description = 'Generates an aggregate report from all subprojects'

    // Get list of projects which should be included in the report
    def projects = new ArrayList()
    subprojects.each { prj ->
        if (!rootProject.ext.ignoredByJacoco.contains(prj.name)) {
            projects.add(prj)
        }
    }

    //noinspection GrUnresolvedAccess
    dependsOn(projects.jacocoReport)

    additionalSourceDirs = generateSourceFiles(projects)
    sourceDirectories = generateSourceFiles(projects)
    classDirectories = generateClassDirs(projects, rootProject.ext.moduleClassDirs,
            rootProject.ext.moduleExcludes)
    executionData = files(projects.jacocoReport.executionData)

    reports {
        html {
            enabled true
            destination 'build/reports/jacoco/full'
        }
        xml {
            enabled true
            destination 'build/reports/jacoco/full/jacocoFullReport.xml'
        }
    }

    doFirst {
        //noinspection GroovyAssignabilityCheck
        executionData = files(executionData.findAll { it.exists() })
    }
}

/**
 *  Generate a FileCollection of all projects source files
 */
FileCollection generateSourceFiles(Collection projects) {
    def dirs = []

    projects.each { prj ->
        dirs.add("${prj.name}/src/main/java")
    }

    return files(dirs)
}

/**
 *  Generate a FileCollection of all projects class files
 */
FileCollection generateClassDirs(Collection projects, moduleClassDirs, moduleExcludes) {
    def tree = fileTree('directory does not exists')
    // I know it's ugly :)

    projects.each { prj ->
        //noinspection GrReassignedInClosureLocalVar
        tree += fileTree(
                dir: "${prj.name}/${moduleClassDirs[prj.name]}",
                excludes: moduleExcludes[prj.name]
        )
    }

    return tree
}

List<File> listDirRecursive(File rootPath) {
    List<File> result = new ArrayList<>()
    List<File> children = rootPath.listFiles()
    children.each { file ->
        if (file.isFile()) {
            result.add(file)
        } else if (file.isDirectory()) {
            result.addAll(listDirRecursive(file))
        }
    }
    return result
}

void renameClasses(String rootPath) {
    List<File> classes = listDirRecursive(file(rootPath))
    classes.each { file ->
        if (file.name.contains('$$')) {
            file.renameTo(file.path.replace('$$', '$'))
        }
    }
}