build.gradle

buildscript {
    repositories {
        mavenCentral()
        jcenter()
    }

    dependencies {
        classpath Libs.kotlin_gradle_plugin
        classpath Libs.gradle_cobertura_plugin
        classpath Libs.coveralls_gradle_plugin
        classpath Libs.dokka_gradle_plugin
    }
}

plugins {
    id "com.jfrog.bintray" version "1.8.4"
    id 'net.saliman.cobertura' version '2.5.4'
    id 'nebula.provided-base' version '3.0.3'
    id 'com.github.kt3k.coveralls' version '2.8.2'
    id 'jmfayard.github.io.gradle-kotlin-dsl-libs' version "0.2.6"
}

allprojects {

    repositories {
        mavenCentral()
        jcenter()
    }

    apply plugin: 'kotlin'
    apply plugin: 'jacoco'
    apply plugin: 'cobertura'
    apply plugin: 'com.github.kt3k.coveralls'
    apply plugin: 'com.jfrog.bintray'
    apply plugin: 'maven'
    apply plugin: 'maven-publish'
    apply plugin: 'nebula.provided-base'
    apply plugin: 'org.jetbrains.dokka'

    jacoco {
        toolVersion = '0.8.3'
    }

    cobertura.coverageFormats = ['hml', 'xml']
    cobertura.coverageSourceDirs = ['src/main/kotlin']

    compileKotlin.kotlinOptions.jvmTarget = "1.8"
    compileTestKotlin.kotlinOptions.jvmTarget = "1.8"

    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8

    version = project.hasProperty('releaseVersion') ? project.releaseVersion : 'LOCAL'
    group = 'org.http4k'

    test {
        useJUnitPlatform()
    }

    task sourcesJar(type: Jar, dependsOn: classes) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

//    task dokkaJavadoc(type: org.jetbrains.dokka.gradle.DokkaTask, overwrite: true, dependsOn: javadoc) {
//        outputDirectory = javadoc.destinationDir
//        outputFormat = "javadoc"
//        processConfigurations = []
//    }
//    task javadocJar(type: Jar, dependsOn: dokkaJavadoc) {
//        classifier = 'javadoc'
//        from dokkaJavadoc.outputDirectory
//    }

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

    task testJar(type: Jar) {
        classifier "test"
        from sourceSets.test.output
    }

    configurations {
        testArtifacts.extendsFrom testRuntime
    }

    artifacts {
        testArtifacts testJar
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                mavenJava(MavenPublication) {
                    artifactId = archivesBaseName

                    pom.withXml {
                        asNode().appendNode('name', archivesBaseName)
                        asNode().appendNode('description', description)
                        asNode().appendNode('url', 'https://http4k.org')
                        asNode().appendNode('developers')
                                .appendNode('developer').appendNode('name', 'Ivan Sanchez').parent().appendNode('email', 'ivan@http4k.org')
                                .parent().parent()
                                .appendNode('developer').appendNode('name', 'David Denton').parent().appendNode('email', 'david@http4k.org')
                        asNode().appendNode('scm').
                                appendNode('url', 'git@github.com:http4k/' + archivesBaseName + '.git').parent().
                                appendNode('connection', 'scm:git:git@github.com:http4k/' + archivesBaseName + '.git').parent().
                                appendNode('developerConnection', 'scm:git:git@github.com:http4k/' + archivesBaseName + '.git')
                        asNode().appendNode('licenses').appendNode('license').
                                appendNode('name', 'Apache License, Version 2.0').parent().
                                appendNode('url', 'http://www.apache.org/licenses/LICENSE-2.0.html')
                    }
                    from components.java

                    artifact sourcesJar
                    artifact javadocJar
                }
            }
        }
    }

    bintray {
        user = System.getenv('BINTRAY_USER')
        key = System.getenv('BINTRAY_KEY')

        publications = ['mavenJava']
        dryRun = false
        publish = true
        pkg {
            repo = 'maven'
            userOrg = 'http4k'
            name = project.name

            desc = description
            websiteUrl = 'https://github.com/http4k/http4k'
            issueTrackerUrl = 'https://github.com/http4k/http4k/issues'
            vcsUrl = 'https://github.com/http4k/http4k.git'
            licenses = ['Apache-2.0']
            labels = []
            publicDownloadNumbers = true
            version {
                name = project.version
                vcsTag = project.version
                gpg {
                    sign = true
                }
                mavenCentralSync {
                    sync = false
                    user = System.getenv('SONATYPE_USER')
                    password = System.getenv('SONATYPE_KEY')
                    close = '1'
                }
            }
        }
    }

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

coveralls {
    sourceDirs = files(subprojects.sourceSets.main.allSource.srcDirs).files.absolutePath
    jacocoReportPath = file("${buildDir}/reports/jacoco/test/jacocoRootReport.xml")
}

task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
    dependsOn = subprojects.test
    sourceDirectories = files(subprojects.sourceSets.main.allSource.srcDirs)
    classDirectories = files(subprojects.sourceSets.main.output)
    executionData = files(subprojects.jacocoTestReport.executionData)
    reports {
        html.enabled = true
        xml.enabled = true
        csv.enabled = false
        xml.destination = file("${buildDir}/reports/jacoco/test/jacocoRootReport.xml")
    }
}

dependencies {
    provided Libs.kotlin_stdlib_jdk8

    provided project(":http4k-core")
    provided project(":http4k-aws")
    provided project(":http4k-client-apache")
    provided project(":http4k-client-apache-async")
    provided project(":http4k-client-jetty")
    provided project(":http4k-client-okhttp")
    provided project(":http4k-client-websocket")
    provided project(":http4k-cloudnative")
    provided project(":http4k-contract")
    provided project(":http4k-format-argo")
    provided project(":http4k-format-gson")
    provided project(":http4k-format-jackson")
    provided project(":http4k-format-jackson-xml")
    provided project(":http4k-format-moshi")
    provided project(":http4k-format-xml")
    provided project(":http4k-incubator")
    provided project(":http4k-jsonrpc")
    provided project(":http4k-metrics-micrometer")
    provided project(":http4k-multipart")
    provided project(":http4k-resilience4j")
    provided project(":http4k-security-oauth")
    provided project(":http4k-server-apache")
    provided project(":http4k-server-jetty")
    provided project(":http4k-server-ktorcio")
    provided project(":http4k-server-netty")
    provided project(":http4k-server-undertow")
    provided project(":http4k-serverless-lambda")
    provided project(":http4k-template-dust")
    provided project(":http4k-template-freemarker")
    provided project(":http4k-template-handlebars")
    provided project(":http4k-template-pebble")
    provided project(":http4k-template-thymeleaf")
    provided project(":http4k-template-dust")
    provided project(":http4k-testing-approval")
    provided project(":http4k-testing-chaos")
    provided project(":http4k-testing-hamkrest")
    provided project(":http4k-testing-webdriver")

    testCompile Config.TestDependencies
}

sourceSets {
    test {
        kotlin {
            srcDirs 'src/test/kotlin'
            srcDirs 'src/docs'
        }
        resources {
            srcDir 'src/docs'
        }
    }
}

task dokka(type: org.jetbrains.dokka.gradle.DokkaTask, overwrite: true) {
    includes = ['src/packages.md']
    moduleName = "$rootProject.name"
    outputDirectory = "$buildDir/ddoc"
    outputFormat = "gfm"
    processConfigurations = []

    sourceDirs = files(subprojects.collect {
        p ->

            def path = new File(p.projectDir, "/src/main/kotlin")

            def relativePath = rootDir.toPath().relativize(path.toPath()).toString()
            linkMapping {
                dir = path.toString().replace(File.separator, "/")
                url = "https://github.com/http4k/http4k/blob/master/$relativePath"
                suffix = "#L"
            }

            return path
    })
}