plugin-tasks.gradle

/*
 * Copyright 2022 Thoughtworks, Inc.
 *
 * 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.
 */
import groovy.xml.MarkupBuilder

processResources {
    from("src/main/resource-templates") {
        duplicatesStrategy(DuplicatesStrategy.INCLUDE)
        filesMatching('plugin.xml') {
            expand project.pluginDesc
        }

        filesMatching('plugin.properties') {
            expand project.pluginDesc
        }

        filesMatching('version.properties') {
            expand project.pluginDesc
        }
    }
}

project.ext.color = [
        ANSI_BOLD_WHITE: "\u001B[0;1m",
        ANSI_RESET     : "\u001B[0m",
        ANSI_RED       : "\u001B[31m",
        ANSI_GREEN     : "\u001B[32m",
        ANSI_YELLOW    : "\u001B[33m",
        ANSI_WHITE     : "\u001B[37m"
]

project.ext.symbols = [
        CHECK_MARK  : "\u2714",
        NEUTRAL_FACE: "\u0CA0_\u0CA0",
        X_MARK      : "\u2718"
]

tasks.withType(JavaCompile) {
    options.deprecation = true
    options.encoding = 'utf-8'
    options.warnings = true
    options.compilerArgs << "-Xlint:all"
    options.compilerArgs << "-Xlint:-serial"
}

tasks.withType(Jar) { jarTask ->
    preserveFileTimestamps = false
    reproducibleFileOrder = true

    ['MD5', 'SHA1', 'SHA-256'].each { algo ->
        jarTask.outputs.files("${jarTask.archiveFile.get()}.${algo}")
        jarTask.doLast {
            ant.checksum file: jarTask.archiveFile.get(), format: 'MD5SUM', algorithm: algo
        }
    }


    manifest {
        attributes(
                'Go-Version': project.pluginDesc.goCdVersion,
                'Plugin-Revision': project.pluginDesc.version,
                'Implementation-Title': project.name,
                'Implementation-Version': project.version,
                'Source-Compatibility': project.java.sourceCompatibility,
                'Target-Compatibility': project.java.targetCompatibility
        )
    }
}

tasks.withType(Test) {
    maxParallelForks = 1

    testLogging {
        def previousFailed = false
        exceptionFormat 'full'

        beforeSuite { suite ->
            if (suite.name.startsWith("Test Run") || suite.name.startsWith("Gradle Worker")) return

            if (suite.parent != null && suite.className != null) {
                println(project.color.ANSI_BOLD_WHITE + suite.name + project.color.ANSI_RESET)
            }
        }

        beforeTest {
            if (previousFailed) {
                System.err.println("")
            }
        }

        afterTest { descriptor, result ->
            previousFailed = false
            def executionTime = (result.endTime - result.startTime) / 1000
            println("    ${resultIndicator(result)}$project.color.ANSI_RESET $descriptor.name $project.color.ANSI_YELLOW($executionTime seconds)$project.color.ANSI_RESET")

            if (result.failedTestCount > 0) {
                previousFailed = true
                println('')
                println(result.exception)
            }
        }

        afterSuite { desc, result ->
            if (desc.parent != null && desc.className != null) {
                println("")
            }

            if (!desc.parent) { // will match the outermost suite
                def failStyle = project.color.ANSI_RED
                def skipStyle = project.color.ANSI_YELLOW
                def summaryStyle = summaryStyle(result)

                if (result.failedTestCount > 0) {
                    failStyle = project.color.ANSI_RED
                }
                if (result.skippedTestCount > 0) {
                    skipStyle = project.color.ANSI_YELLOW
                }


                println("--------------------------------------------------------------------------")
                println("Results: $summaryStyle$result.resultType$project.color.ANSI_RESET ($result.testCount tests, $project.color.ANSI_GREEN$result.successfulTestCount passed$project.color.ANSI_RESET, $failStyle$result.failedTestCount failed$project.color.ANSI_RESET, $skipStyle$result.skippedTestCount skipped$project.color.ANSI_RESET)")
                println("--------------------------------------------------------------------------")
            }
        }
    }
}

private String summaryStyle(result) {
    def summaryStyle = project.color.ANSI_WHITE
    switch (result.resultType) {
        case TestResult.ResultType.SUCCESS:
            summaryStyle = project.color.ANSI_GREEN
            break
        case TestResult.ResultType.FAILURE:
            summaryStyle = project.color.ANSI_RED
            break
    }
    summaryStyle
}

private String resultIndicator(result) {
    def indicator = project.color.ANSI_WHITE

    if (result.failedTestCount > 0) {
        indicator = project.color.ANSI_RED + project.symbols.X_MARK
    } else if (result.skippedTestCount > 0) {
        indicator = project.color.ANSI_YELLOW + project.symbols.NEUTRAL_FACE
    } else {
        indicator = project.color.ANSI_GREEN + project.symbols.CHECK_MARK
    }
    indicator
}

task previewGithubRelease() {
    doLast {
        def prerelease = !"No".equalsIgnoreCase(System.getenv('PRERELEASE'))
        def lastTag = project.git.getLastTag(prerelease)
        def targetCommitish = project.git.gitRevision()
        def assets = subprojects.findAll { it.name != "common" }
                .collect { it.jar.outputs.files.files }
                .flatten()
        def tagName = "${project.fullVersion}${prerelease ? '-exp' : ''}"

        def releaseName = "${prerelease ? 'Experimental: ' : ''}${project.fullVersion}"
        def changelogHeader = lastTag ? "Changelog ${lastTag}..${project.fullVersion}" : "Changelog"

        def changes = project.git.getCommitsSinceLastTag(lastTag).replaceAll("\"", "").stripIndent().trim()

        def previewFile = file("${project.buildDir}/preview.html")
        if (!previewFile.exists()) {
            previewFile.createNewFile()
        }
        def html = new MarkupBuilder(new FileWriter(previewFile))
        html.html {
            body {
                div {
                    h1(project.pluginDesc.repo)
                    h3(releaseName)
                    div {
                        b("Tag: ")
                        span(tagName)
                    }
                    div {
                        b("Commit: ")
                        span(targetCommitish.substring(0, 7))
                    }

                    div {
                        h4("Assets")
                        assets.each { div(it.getName() + " - " + project.git.readableFileSize(it.length())) }
                    }

                    div {
                        h4(changelogHeader)
                        p {
                            changes.split("\n").each { div(it) }
                        }
                    }
                }
            }
        }
        def output_preview = file("$rootProject.buildDir/preview.html")
        if (output_preview.exists()) {
            output_preview.append(previewFile.text)
        } else {
            output_preview.write(previewFile.text)
        }
    }
}

task deploy() {
    dependsOn assemble
    description 'Run ./gradlew deploy -Pserver_path=~/gocd to deploy plugin'
    doLast {
        if (project.hasProperty('server_path')) {
            def server_path = "$server_path"
            project.copy {
                from "$project.buildDir/libs/"
                include "*.jar"
                into server_path
            }
        } else {
            throw new GradleScriptException('Run ./gradlew deploy -Pserver_path=~/gocd to deploy plugin', null)
        }
    }
}

previewGithubRelease.dependsOn assemble