build.gradle

import java.nio.file.Files
import java.nio.file.Paths
import java.nio.file.Path

plugins {
    id 'java'
    id 'jacoco'
    id 'signing'
    id 'maven-publish'
    id 'com.github.ben-manes.versions' version '0.40.0'
    id 'net.researchgate.release' version '3.0.2'
    id 'org.ajoberstar.grgit' version '5.2.1'
    id 'org.sonarqube' version '4.4.1.3373'
}

group = 'io.bit3'
description = 'SASS compiler using libsass.'

java {
    withJavadocJar()
    withSourcesJar()

    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
}

jar {
    manifest {
        attributes 'Implementation-Title': 'jsass',
                'Implementation-Version': version
    }
}

repositories {
    mavenCentral()
}

dependencyLocking {
    lockAllConfigurations()
}

dependencies {
    implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.14.0'
    implementation group: 'commons-io', name: 'commons-io', version: '2.15.1'
    implementation group: 'org.apache.commons', name: 'commons-text', version: '1.11.0'
    implementation group: 'org.slf4j', name: 'slf4j-api', version: '1.7.28'
    implementation group: 'org.sharegov', name: 'mjson', version: '1.4.1'
    testRuntimeOnly group: 'org.slf4j', name: 'slf4j-simple', version: '1.7.28'
    testImplementation('org.junit.jupiter:junit-jupiter-api:5.10.1')
    testImplementation('org.junit.jupiter:junit-jupiter-params:5.10.1')
    testImplementation('org.junit.jupiter:junit-jupiter-engine:5.10.1')
    testImplementation('org.hamcrest:hamcrest-library:1.3')
}

dependencyUpdates.resolutionStrategy {
    componentSelection { rules ->
        rules.all { ComponentSelection selection ->
            boolean rejected = ['alpha', 'beta', 'rc', 'cr', 'm', 'preview'].any { qualifier ->
                selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-]*/
            }
            if (rejected) {
                selection.reject('Release candidate')
            }
        }
    }
}

test {
    useJUnitPlatform()

    systemProperty 'org.slf4j.simpleLogger.log.io.bit3.jsass', 'trace'

    if (project.hasProperty('test.tmpdir')) {
        Path path = Paths.get(Objects.toString(project.findProperty('test.tmpdir')))
        systemProperty 'java.io.tmpdir', path.toAbsolutePath().normalize().toString()
    }
}

tasks.register('testOnJava8', Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(8)
    }

    useJUnitPlatform()

    systemProperty 'org.slf4j.simpleLogger.log.io.bit3.jsass', 'trace'

    if (project.hasProperty('test.tmpdir')) {
        Path path = Paths.get(Objects.toString(project.findProperty('test.tmpdir')))
        systemProperty 'java.io.tmpdir', path.toAbsolutePath().normalize().toString()
    }
}

tasks.register('testOnJava17', Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(17)
    }

    useJUnitPlatform()

    systemProperty 'org.slf4j.simpleLogger.log.io.bit3.jsass', 'trace'

    if (project.hasProperty('test.tmpdir')) {
        Path path = Paths.get(Objects.toString(project.findProperty('test.tmpdir')))
        systemProperty 'java.io.tmpdir', path.toAbsolutePath().normalize().toString()
    }
}

tasks.register('testOnJava21', Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(21)
    }

    useJUnitPlatform()

    systemProperty 'org.slf4j.simpleLogger.log.io.bit3.jsass', 'trace'

    if (project.hasProperty('test.tmpdir')) {
        Path path = Paths.get(Objects.toString(project.findProperty('test.tmpdir')))
        systemProperty 'java.io.tmpdir', path.toAbsolutePath().normalize().toString()
    }
}

check {
    dependsOn 'testOnJava8', 'testOnJava17', 'testOnJava21'
}

sonarqube {
    properties {
        def description = grgit.describe()

        property "sonar.exclusions", "**/src/main/libsass/**"
        property "sonar.projectVersion", description
        property "sonar.jacoco.reportPath", "${project.buildDir}/jacoco/test.exec"
    }
}

// jni header generation
task jniMainHeaders(type:Exec) {
    def javaVersion = JavaVersion.current()
    def isJava9Compatible = javaVersion.isJava9Compatible()

    def mainClasspath = sourceSets.main.output.classesDirs.asPath
    if (isJava9Compatible) {
        // JDK 9 or newer
        commandLine "javac", "-h", "src/main/c", "-classpath", mainClasspath, "src/main/java/io/bit3/jsass/adapter/NativeAdapter.java"
    } else {
        // JDK 8 or older
        commandLine "javah", "-classpath", mainClasspath, "-d", "src/main/c", "-jni", "-force", "io.bit3.jsass.adapter.NativeAdapter"
    }

    dependsOn classes
}

// jni header generation
task jniTestHeaders(type:Exec) {
    def javaVersion = JavaVersion.current()
    def isJava9Compatible = javaVersion.isJava9Compatible()

    def testClasspath = sourceSets.test.output.classesDirs.asPath
    if (isJava9Compatible) {
        // JDK 9 or newer
        commandLine "javac", "-h", "src/test/c", "-classpath", testClasspath, "src/test/java/io/bit3/jsass/adapter/NativeTestAdapter.java"
    } else {
        // JDK 8 or older
        commandLine "javah", "-classpath", testClasspath, "-d", "src/test/c", "-jni", "-force", "io.bit3.jsass.adapter.NativeTestAdapter"
    }

    dependsOn testClasses
}

// jni header generation
task jniHeaders() {
    dependsOn jniMainHeaders
    dependsOn jniTestHeaders
}

jar.dependsOn jniHeaders

javadoc {
    options.addBooleanOption('html5', true)
}

publishing {
    if (project.hasProperty("ossrhUsername") && project.hasProperty("ossrhPassword")) {
        repositories {
            maven {
                name = "MavenCentral"
                url(version.endsWith("-SNAPSHOT") ? "https://oss.sonatype.org/content/repositories/snapshots/" : "https://oss.sonatype.org/service/local/staging/deploy/maven2/")
                credentials {
                    username ossrhUsername
                    password ossrhPassword
                }
            }
        }
    }

    var ciJobToken = System.getenv("CI_JOB_TOKEN")
    var ciApiUrl = System.getenv("CI_API_V4_URL")
    var ciProjectId = System.getenv("CI_PROJECT_ID")

    if (ciJobToken && ciApiUrl && ciProjectId) {
        repositories {
            maven {
                name = "Gitlab"
                url("${ciApiUrl}/projects/${ciProjectId}/packages/maven")
                credentials(HttpHeaderCredentials) {
                    name = 'Job-Token'
                    value = ciJobToken
                }
                authentication {
                    header(HttpHeaderAuthentication)
                }
            }
        }
    }

    publications {
        maven(MavenPublication) {
            groupId = 'io.bit3'
            artifactId = 'jsass'
            version = project.version

            from components.java

            pom {
                name = 'jsass'
                description = 'SASS compiler using libsass.'
                url = 'https://gitlab.com/jsass/jsass'

                licenses {
                    license {
                        name = 'MIT'
                        url = 'https://raw.githubusercontent.com/bit3/jsass/master/LICENSE'
                    }
                }

                organization {
                    name = 'bit3'
                    url = 'http://bit3.io'
                }

                developers {
                    developer {
                        id = 'tril'
                        name = 'Tristan Lins'
                        email = 'tristan@lins.io'
                        url = 'https://tristan.lins.io'
                    }
                }

                issueManagement {
                    system = 'GitLab.com'
                    url = 'https://gitlab.com/jsass/jsass/issues'
                }

                ciManagement {
                    system = 'GitLab.com'
                    url = 'https://gitlab.com/jsass/jsass/pipelines'
                }

                scm {
                    url = 'https://gitlab.com/jsass/jsass'
                    connection = 'scm:git:https://gitlab.com/jsass/jsass.git'
                    developerConnection = 'scm:git:git@gitlab.com:jsass/jsass.git'
                }
            }
        }
    }
}

// signing artifacts
if (project.hasProperty("signing.gnupg.keyName") && project.hasProperty("signing.gnupg.passphrase")) {
    signing {
        useGpgCmd()
        sign publishing.publications.maven
    }
} else if (project.hasProperty("signing.keyId") && project.hasProperty("signing.password")) {
    signing {
        sign publishing.publications.maven
    }
}

// -----------------------------------------------------------------------------

def isVerbose() {
    def logLevel = gradle.startParameter.logLevel
    return LogLevel.INFO == logLevel || LogLevel.DEBUG == logLevel
}

task determineUid() {
    def file = new File(project.buildDir, "uid")

    project.ext['uid'] = file.canRead() ? new String(file.readBytes()) : 0
    outputs.file(file)

    doLast {
        def user = System.getProperty("user.name")
        def output = new ByteArrayOutputStream()
        exec {
            commandLine 'id', '-u', user
            standardOutput = output
        }
        def uid = output.toString().trim()
        file.write((String) uid)
        project.ext['uid'] = uid
    }
}

task determineGid() {
    def file = new File(project.buildDir, "gid")

    project.ext['gid'] = file.canRead() ? new String(file.readBytes()) : 0
    outputs.file(file)

    doLast {
        def user = System.getProperty("user.name")
        def output = new ByteArrayOutputStream()
        exec {
            commandLine 'id', '-g', user
            standardOutput = output
        }
        def gid = output.toString().trim()
        file.write((String) gid)
        project.ext['gid'] = gid
    }
}

task determineRepositoryHeadStability() {
    project.ext['headIsUpstream'] = true

    doLast {
        def branch = grgit.branch.current()

        if (branch) {
            branch = branch.getName()
        }

        if (!branch || 'HEAD' == branch) {
            def tag = grgit.describe()

            project.ext['headIsUpstream'] = !(tag =~ /^\d+(\.\d+)+$/)
        } else {
            project.ext['headIsUpstream'] = 'master' != branch
        }
    }
}

task determineDockerAvailable() {
    def file = new File(project.buildDir, "docker")
    outputs.file(file)

    doLast {
        def podmanExecResult = exec {
            commandLine 'podman', '--version'
            ignoreExitValue = true
            standardOutput = new ByteArrayOutputStream()
            errorOutput = standardOutput
        }

        if (podmanExecResult.exitValue == 0) {
            file.write("podman")
        } else {
            def dockerExecResult = exec {
                commandLine 'docker', '--version'
                ignoreExitValue = true
                standardOutput = new ByteArrayOutputStream()
                errorOutput = standardOutput
            }

            if (dockerExecResult.exitValue == 0) {
                file.write("docker")
            } else {
                throw new GradleException("Docker or Podman is required to run this task")
            }
        }
    }
}

def pullDockerContainer(name) {
    def dockerCmd = Files.readString(new File(project.buildDir, "docker").toPath())
    def output = new ByteArrayOutputStream()
    def execResult = exec {
        workingDir project.projectDir
        commandLine dockerCmd, 'pull', "registry.gitlab.com/jsass/docker/$name:latest"

        if (!isVerbose()) {
            standardOutput = output
            errorOutput = output
            ignoreExitValue = true
        }
    }

    if (execResult.exitValue != 0) {
        throw new GradleException("Docker pull failed\n" + output.toString())
    }
}

def runDockerContainer(name, String buildFile) {
    def dockerCmd = Files.readString(new File(project.buildDir, "docker").toPath())
    pullDockerContainer(name)

    def output = new ByteArrayOutputStream()
    def execResult = exec {
        workingDir project.projectDir
        commandLine dockerCmd, 'run', "--user=$uid:$gid", '--userns=keep-id', '--rm', '--security-opt', 'label=disable', '-v', "${project.projectDir}:/jsass:z", "registry.gitlab.com/jsass/docker/$name:latest", buildFile

        if (!isVerbose()) {
            standardOutput = output
            errorOutput = output
            ignoreExitValue = true
        }
    }

    if (execResult.exitValue != 0) {
        throw new GradleException("Docker run failed\n" + output.toString())
    }
}

// -----------------------------------------------------------------------------

// Build native libs
task buildNativeLibs {
    dependsOn 'buildNativeDarwinAmd64Libs',
              'buildNativeDarwinArm64Libs',
              'buildNativeLinuxAmd64Libs',
              'buildNativeLinuxArmhf32Libs',
              'buildNativeLinuxAarch64Libs',
              'buildNativeWindows64Libs'
}

task buildNativeDarwinAmd64Libs {
    dependsOn determineUid, determineGid, determineRepositoryHeadStability, determineDockerAvailable

    doLast {
        println 'Build native libs for darwin amd64'
        runDockerContainer('build-libsass-darwin', '/make-x86_64.sh')
    }
}

task buildNativeDarwinArm64Libs {
    dependsOn determineUid, determineGid, determineRepositoryHeadStability, determineDockerAvailable

    doLast {
        println 'Build native libs for darwin amd64'
        runDockerContainer('build-libsass-darwin', '/make-aarch64.sh')
    }
}

task buildNativeLinuxAmd64Libs {
    dependsOn determineUid, determineGid, determineRepositoryHeadStability, determineDockerAvailable

    doLast {
        println 'Build native libs for linux amd64'
        runDockerContainer('build-libsass-linux-x64', '/make.sh')
    }
}

task buildNativeLinuxArmhf32Libs {
    dependsOn determineUid, determineGid, determineRepositoryHeadStability, determineDockerAvailable

    doLast {
        println 'Build native libs for linux armhf32'
        runDockerContainer('build-libsass-linux-arm', '/make-armhf32.sh')
    }
}

task buildNativeLinuxAarch64Libs {
    dependsOn determineUid, determineGid, determineRepositoryHeadStability, determineDockerAvailable

    doLast {
        println 'Build native libs for linux aarch64'
        runDockerContainer('build-libsass-linux-arm', '/make-aarch64.sh')
    }
}

task buildNativeWindows64Libs {
    dependsOn determineUid, determineGid, determineRepositoryHeadStability, determineDockerAvailable

    doLast {
        println 'Build native libs for windows amd64'
        runDockerContainer('build-libsass-windows-x64', '/make.sh')
    }
}