build.gradle

import java.util.jar.JarInputStream

plugins {
    id 'java'
    id 'jacoco'
    id 'com.jfrog.artifactory' version '4.28.2'
    id 'org.sonarqube' version '3.5.0.2730'
    id 'de.thetaphi.forbiddenapis' version '3.0' apply false
    id 'com.diffplug.spotless' version '6.15.0'
}

allprojects {
    apply plugin: 'java'
    apply plugin: 'jacoco'
    apply plugin: 'com.jfrog.artifactory'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'

    gradle.projectsEvaluated {
        tasks.withType(JavaCompile).configureEach {
            if (project.hasProperty('warn')) {
                options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation"
            } else {
                options.compilerArgs << "-Xlint:-unchecked" << "-Xlint:-deprecation"
            }
        }
    }

    ext {
        buildNumber = System.getProperty("buildNumber")

        sonarLinksCi = 'https://cirrus-ci.com/github/SonarSource/sonar-scala'
        sonarLinksScm = 'https://github.com/SonarSource/sonar-scala'

        artifactsToPublish = ''
        artifactsToDownload = ''
    }
    // Replaces the version defined in sources, usually x.y-SNAPSHOT, by a version identifying the build.
    if (version.endsWith('-SNAPSHOT') && ext.buildNumber != null) {
        def versionSuffix = (version.toString().count('.') == 1 ? ".0.${ext.buildNumber}" : ".${ext.buildNumber}")
        version = version.replace('-SNAPSHOT', versionSuffix)
    }

    repositories {
        mavenLocal()
        def artifactoryBearerToken = System.getenv("ARTIFACTORY_PRIVATE_PASSWORD") ?: project.findProperty("artifactoryPassword")
        if (artifactoryBearerToken) {
            maven {
                url "https://repox.jfrog.io/repox/sonarsource"
                authentication {
                    header(HttpHeaderAuthentication)
                }
                credentials(HttpHeaderCredentials) {
                    name = "Authorization"
                    value = "Bearer $artifactoryBearerToken"
                }
            }
        }
        mavenCentral()
    }
}

subprojects {
    // do not publish to Artifactory by default
    artifactoryPublish.skip = true

    apply plugin: 'com.diffplug.spotless'

    java {
        sourceCompatibility = JavaVersion.VERSION_17
        withSourcesJar()
        withJavadocJar()
    }

    tasks.withType(JavaCompile) {
        options.encoding = "UTF-8"
        options.release = java.sourceCompatibility.majorVersion as int
    }

    jacoco {
        toolVersion = "0.8.7"
    }

    jacocoTestReport {
        reports {
            xml.required = true
            csv.required = false
            html.required = false
        }
    }

    // when subproject has Jacoco pLugin applied we want to generate XML report for coverage
    plugins.withType(JacocoPlugin) {
        tasks["test"].finalizedBy 'jacocoTestReport'
    }

    configurations {
        // include compileOnly dependencies during test
        testCompile.extendsFrom compileOnly
    }

    if (!project.path.startsWith(":its")) {
        test {
            useJUnitPlatform()
        }
    }

    test {
        testLogging {
            exceptionFormat 'full' // log the full stack trace (default is the 1st line of the stack trace)
            events "skipped", "failed" // verbose log for failed and skipped tests (by default the name of the tests are not logged)
        }
        def propKeys = System.properties.findAll {
            it.key.startsWith("orchestrator") || it.key.startsWith("sonar") || it.key == "buildNumber" || it.key == "slangVersion"
        }.collect { it.key }
        systemProperties = System.properties.subMap(propKeys)
        if (propKeys.contains("buildNumber") && !propKeys.contains("slangVersion")) {
            systemProperties["slangVersion"] = version
        }
    }

    // license updater
    spotless {
        java {
            targetExclude "**/src/test/resources/**", "**/build/**", "its/sources/**", "its/plugin/projects/**"
            licenseHeaderFile(rootProject.file("LICENSE_HEADER")).updateYearWithLatest(true)
        }
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                pom {
                    name = projectTitle
                    description = project.description
                    url = 'http://www.sonarqube.org/'
                    organization {
                        name = 'SonarSource'
                        url = 'http://www.sonarsource.com'
                    }
                    licenses {
                        license {
                            name = 'SONAR Source-Available License v1.0'
                            url = 'https://www.sonarsource.com/license/ssal/'
                            distribution = 'repo'
                        }
                    }
                    scm {
                        url = 'https://github.com/SonarSource/sonar-scala'
                    }
                    developers {
                        developer {
                            id = 'sonarsource-team'
                            name = 'SonarSource Team'
                        }
                    }
                }
            }
        }
    }

    signing {
        def signingKeyId = findProperty("signingKeyId")
        def signingKey = findProperty("signingKey")
        def signingPassword = findProperty("signingPassword")
        useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)
        required {
            def branch = System.getenv()["CIRRUS_BRANCH"]
            return (branch == 'master' || branch ==~ 'branch-[\\d.]+') &&
                    gradle.taskGraph.hasTask(":artifactoryPublish")
        }
        sign publishing.publications
    }

    tasks.withType(Sign) {
        onlyIf {
            def branch = System.getenv()["CIRRUS_BRANCH"]
            return !artifactoryPublish.skip &&
                    (branch == 'master' || branch ==~ 'branch-[\\d.]+') &&
                    gradle.taskGraph.hasTask(":artifactoryPublish")
        }
    }
}

sonar {
    properties {
        property 'sonar.projectKey', 'SonarSource_sonar-scala'
        property 'sonar.projectName', projectTitle
        property 'sonar.links.ci', "${sonarLinksCi}"
        property 'sonar.links.scm', "${sonarLinksScm}"
        property 'sonar.links.issue', 'https://jira.sonarsource.com/browse/SONARSCALA'
        property 'sonar.exclusions', '**/build/**/*'
    }
}

artifactory {
    clientConfig.setIncludeEnvVars(true)
    clientConfig.setEnvVarsExcludePatterns('*password*,*PASSWORD*,*secret*,*MAVEN_CMD_LINE_ARGS*,sun.java.command,*token*,*TOKEN*,*LOGIN*,*login*,*key*,*KEY*,*PASSPHRASE*,*signing*')
    contextUrl = System.getenv('ARTIFACTORY_URL')
    publish {
        repository {
            repoKey = System.getenv('ARTIFACTORY_DEPLOY_REPO')
            username = System.getenv('ARTIFACTORY_DEPLOY_USERNAME')
            password = System.getenv('ARTIFACTORY_DEPLOY_PASSWORD')
        }
        defaults {
            properties = [
                'build.name': 'sonar-scala',
                'build.number': System.getenv('BUILD_NUMBER'),
                'pr.branch.target': System.getenv('PULL_REQUEST_BRANCH_TARGET'),
                'pr.number': System.getenv('PULL_REQUEST_NUMBER'),
                'vcs.branch': System.getenv('GIT_BRANCH'),
                'vcs.revision': System.getenv('GIT_COMMIT'),
                'version': version
            ]
            publications('mavenJava')
            publishPom = true
            publishIvy = false
        }
    }

    clientConfig.info.setBuildName('sonar-scala')
    clientConfig.info.setBuildNumber(System.getenv('BUILD_NUMBER'))
    // Define the artifacts to be deployed to https://binaries.sonarsource.com on releases
    clientConfig.info.addEnvironmentProperty('ARTIFACTS_TO_PUBLISH', artifactsToPublish)
    clientConfig.info.addEnvironmentProperty('ARTIFACTS_TO_DOWNLOAD', artifactsToDownload)
    // The name of this variable is important because it's used by the delivery process when extracting version from Artifactory build info.
    clientConfig.info.addEnvironmentProperty('PROJECT_VERSION', "${version}")
}

void enforceJarSizeAndCheckContent(File file, long minSize, long maxSize) {
    long size = file.length()
    if (size < minSize)  {
        throw new GradleException("${file.path} size ($size) too small. Min is $minSize")
    } else if (size > maxSize) {
        throw new GradleException("${file.path} size ($size) too large. Max is $maxSize")
    }
    checkJarEntriesPathUniqueness file
}

// A jar should not contain 2 entries with the same path, furthermore Pack200 will fail to unpack it
void checkJarEntriesPathUniqueness(File file) {
    def allNames = new HashSet()
    def duplicatedNames = new HashSet()
    file.withInputStream { input ->
        new JarInputStream(input).withCloseable { jarInput ->
            for (def jarEntry = jarInput.nextJarEntry; jarEntry != null; jarEntry = jarInput.nextJarEntry) {
                if (!allNames.add(jarEntry.name)) {
                    duplicatedNames.add jarEntry.name
                }
            }
        }
    }
    if (!duplicatedNames.empty) {
        throw new GradleException("Duplicated entries in the jar: '${file.path}': ${duplicatedNames.join(', ')}")
    }
}