build.gradle

import org.sonarqube.gradle.SonarQubeTask

buildscript {
    ext {
        //@formatter:off
        grgitVersion                = '4.+'
        sonarqubeVersion            = '2.+'
        versionsVersion             = '0.+'
        bintrayVersion              = '1.+'

        orgJsonVersion              = '20190722'
        springBootVersion           = '[2.2.6.RELEASE, 2.3['
        spotbugsVersion             = '[4.0.1, 5.0['
        annotationsVersion          = '[0.0.2, 0.2['
        immutablesVersion           = '[2.8.3, 3.0['
        jcabiVersion                = '[1.1, 2.0['
        //@formatter:on
    }
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }
    dependencies {
        classpath "org.ajoberstar.grgit:grgit-gradle:${grgitVersion}"
        classpath "org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:${sonarqubeVersion}"
        classpath "com.github.ben-manes:gradle-versions-plugin:${versionsVersion}"
        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:${bintrayVersion}"
    }

    configurations.classpath {
        resolutionStrategy.activateDependencyLocking()
    }
}

apply plugin: 'org.ajoberstar.grgit'
apply plugin: 'com.jfrog.bintray'
apply plugin: 'org.sonarqube'

configure(allprojects.findAll { it.name != 'platform' }) {
    apply plugin: 'java-library'

    dependencies {
        api platform(project(':platform'))
        annotationProcessor platform(project(':platform'))
        compileOnly platform(project(':platform'))

        // annotations
        compileOnly 'com.github.spotbugs:spotbugs-annotations'
        compileOnly 'space.npstr:annotations'

        // immutable objects, to pass values around
        compileOnly(group: 'org.immutables', name: 'value', classifier: 'annotations')
        annotationProcessor 'org.immutables:value'

        //testing
        testImplementation 'org.junit.jupiter:junit-jupiter-api'
        testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
        testRuntimeOnly 'ch.qos.logback:logback-classic'
    }
}

project(':platform') {
    apply plugin: 'java-platform'
    javaPlatform {
        allowDependencies()
    }
    dependencies {
        api platform("org.springframework.boot:spring-boot-dependencies:$springBootVersion")
        constraints {
            api "com.github.spotbugs:spotbugs-annotations:$spotbugsVersion"
            api "org.immutables:value:$immutablesVersion"
            api "org.json:json:$orgJsonVersion"
            api "space.npstr:annotations:$annotationsVersion"
            api "com.jcabi:jcabi-manifests:$jcabiVersion"
        }
    }
}

dependencies {
    api project(':api')
    implementation project(':impl')
}

project(':api') {
    dependencies {
        api platform(project(':platform'))

        api 'org.slf4j:slf4j-api'

        // project reactor & reactive websocket client
        api 'org.springframework:spring-webflux'
        api 'io.projectreactor:reactor-core'
    }
}

project(':impl') {
    dependencies {
        implementation platform(project(':platform'))

        implementation project(':api')

        implementation "org.json:json"
        implementation "com.jcabi:jcabi-manifests"
        implementation 'io.projectreactor.netty:reactor-netty'
    }
}

allprojects {
    apply plugin: 'maven-publish'
    apply plugin: 'jacoco'
    apply plugin: 'com.github.ben-manes.versions'

    group = "space.npstr.magma"
    version = "${versionFromTag()}"
    archivesBaseName = project.name

    sourceCompatibility = targetCompatibility = JavaVersion.VERSION_1_8

    repositories {
        jcenter()
        mavenCentral()
        maven { url 'https://jitpack.io' }
    }

    compileJava {
        options.encoding = 'UTF-8'
        options.incremental = true
        options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation"
    }

    test {
        useJUnitPlatform()
        jacoco {
            includes['space.npstr.magma.*']
        }
    }

    sonarqube {
        properties {
            property "sonar.inclusions", "**/src/main/java/space/npstr/magma/**/*.java"
        }
    }

    tasks.withType(SonarQubeTask) {
        dependsOn jacocoTestReport
    }

    jacocoTestReport {
        reports {
            xml.enabled true
        }
    }

    jar {
        manifest {
            attributes(
                    'Magma-Version': project.version
            )
        }
    }

    publishToMavenLocal.dependsOn jar
    task sourceJar(type: Jar) {
        from sourceSets.main.allJava
        archiveClassifier.set('sources')
    }

    task javadocJar(type: Jar, dependsOn: javadoc) {
        archiveClassifier.set('javadoc')
        from javadoc.destinationDir
    }

    // called by jitpack
    task install {
        dependsOn test
        dependsOn publishToMavenLocal
        doLast {
            println 'Version: ' + version
        }
    }

    defaultTasks 'build'

    publishing {
        publications {
            mavenJava(MavenPublication) {
                if (components.hasProperty('java')) {
                    from components.java
                }
                if (components.hasProperty('javaPlatform')) {
                    from components.javaPlatform
                }
                afterEvaluate {
                    groupId project.group
                    artifactId archivesBaseName
                    version project.version
                }

                artifact sourceJar
                artifact javadocJar

                versionMapping {
                    allVariants {
                        fromResolutionResult()
                    }
                }

                pom {
                    name = 'Magma'
                    description = 'A voice only API for Discord, focused on delivering music at scale.'
                    url = 'https://github.com/napstr/Magma'
                    licenses {
                        license {
                            name = 'Apache License 2.0'
                            url = 'https://choosealicense.com/licenses/apache-2.0/'
                            distribution = 'repo'
                        }
                    }
                    developers {
                        developer {
                            name = 'Napster'
                            email = 'napster@npstr.space'
                        }
                    }
                    scm {
                        url = 'https://github.com/napstr/Magma'
                    }
                }
            }
        }
    }

    bintray {
        user = this.properties["bintrayUsername"]
        key = this.properties["bintrayApiKey"]
        publications = ["mavenJava"]
        pkg {
            repo = "maven"
            name = archivesBaseName
            licenses = ["Apache-2.0"]
            vcsUrl = "https://github.com/napstr/Magma"
            githubRepo = "napstr/Magma"
            publish = true
            version {
                name = project.version
                vcsTag = project.version
                released = new Date()
                gpg.sign = true
            }
        }
    }

    bintrayUpload {
        dependsOn clean
        dependsOn build
        dependsOn javadocJar
        dependsOn sourceJar
        build.mustRunAfter clean
    }

    dependencyUpdates.resolutionStrategy {
        componentSelection properReleasesOnly()
    }

    dependencyLocking {
        lockAllConfigurations()
    }

    // ./gradlew resolveAndLockAll --write-locks
    task resolveAndLockAll {
        doFirst {
            assert gradle.startParameter.writeDependencyLocks
        }
        doLast {
            configurations.all {
                resolutionStrategy {
                    componentSelection properReleasesOnly()
                }
            }
            configurations
                    .findAll { it.canBeResolved }
                    .each { it.resolve() }
        }
    }
}

build {
    doLast {
        println 'Version: ' + version
    }
}


static def properReleasesOnly() {
    return { rules ->
        rules.all { ComponentSelection selection ->
            boolean rejected = ['alpha', 'beta', 'rc', 'preview', 'm1', 'm2', 'm3'].any {
                q -> selection.candidate.version.toLowerCase().contains(q)
            }
            if (rejected) {
                selection.reject('Release candidate')
            }
        }
    }
}

//returns either a git tag if there is one on this commit, or the commit hash, to be used as a version
@SuppressWarnings("GrMethodMayBeStatic")
String versionFromTag() {
    def headTag = grgit.tag.list().find {
        it.commit == grgit.head()
    }

    if (headTag) {
        headTag.getName()
    } else {
        "${grgit.head().id}"
    }
}