build.gradle

buildscript {

    repositories {
        jcenter()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }

    dependencies {
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:0.9.17"
    }
}

plugins {
    id 'org.jetbrains.kotlin.jvm' version '1.3.72'
}

group 'io.rudolph.netatmo'
version '0.5.4'

repositories {
    mavenCentral()
}

apply plugin: 'org.jetbrains.kotlin.jvm'
apply plugin: 'org.jetbrains.dokka'
apply plugin: 'maven-publish'
apply plugin: 'signing'
apply plugin: 'java'

dependencies {
    api 'org.jetbrains.kotlin:kotlin-stdlib:1.3.72'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7'
    implementation 'org.jetbrains.kotlin:kotlin-reflect:1.3.72'
    implementation 'io.github.microutils:kotlin-logging:1.7.9'
    implementation 'org.slf4j:slf4j-simple:1.7.25'
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-jackson:2.9.0'
    implementation('com.fasterxml.jackson.core:jackson-core:2.11.0') {
        exclude group: 'com.fasterxml.jackson.core', module: 'jackson-databind'
    }
    implementation 'com.fasterxml.jackson.core:jackson-annotations:2.11.0'
    implementation "com.fasterxml.jackson.module:jackson-module-kotlin:2.11.0"
    implementation 'com.squareup.okhttp3:okhttp:4.7.2'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.7.2'
    testImplementation 'junit:junit:4.12'
}

dokka {
    outputFormat = 'javadoc'
    outputDirectory = "$buildDir/javadoc"
}

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

jar {
    version = version
    exclude('credentials*.json')
    exclude('/apiresults')

    manifest {
        attributes 'NetatmoApi': 'app.MainKt'
    }
}

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

task customFatJar(type: Jar) {

    manifest {
        attributes 'NetatmoApi': 'app.MainKt'
    }

    baseName = project.name

    from {
        configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
    }
    with jar
}

task copyTestResources(type: Copy) {
    from "${projectDir}/src/test/resources"
    into "${projectDir}/out/test/classes/apitest/"
}
processTestResources.dependsOn copyTestResources

task sourceJar(type: Jar) {
    classifier "sources"
    from sourceSets.main.allJava
}

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

artifacts {
    archives jar
    archives sourceJar
    archives javadocJar
}

signing {
    sign configurations.archives
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            customizePom(pom)
            from components.java

            // create the sign pom artifact
            pom.withXml {
                def pomFile = file("${project.buildDir}/generated-pom.xml")
                writeTo(pomFile)
                def pomAscFile = signing.sign(pomFile).signatureFiles[0]
                artifact(pomAscFile) {
                    classifier = null
                    extension = 'pom.asc'
                }
            }

            artifact(sourceJar) {
                classifier = 'sources'
            }
            artifact(javadocJar) {
                classifier = 'javadoc'
            }

            // create the signed artifacts
            project.tasks.signArchives.signatureFiles.each {
                artifact(it) {
                    def matcher = it.file =~ /-(sources|javadoc)\.jar\.asc$/
                    if (matcher.find()) {
                        classifier = matcher.group(1)
                    } else {
                        classifier = null
                    }
                    extension = 'jar.asc'
                }
            }
        }
    }
    repositories {
        maven {
            url "https://oss.sonatype.org/service/local/staging/deploy/maven2"
            credentials {
                username sonatypeUsername
                password sonatypePassword
            }
        }
    }
}

def customizePom(pom) {
    pom.withXml {
        def root = asNode()

        // eliminate test-scoped dependencies (no need in maven central POMs)
        root.dependencies.removeAll { dep ->
            dep.scope == "test"
        }

        // add all items necessary for maven central publication
        root.children().last() + {
            resolveStrategy = Closure.DELEGATE_FIRST

            description 'API Service for Netatmo'
            name 'Netatmo Java API'
            url 'https://github.com/navybk/netatmo-java-api'
            organization {
                name 'com.github.navybk'
                url 'https://github.com/navybk'
            }
            issueManagement {
                system 'GitHub'
                url 'https://github.com/navybk/netatmo-java-api/issues'
            }
            licenses {
                license {
                    name 'MIT License'
                    url 'https://opensource.org/licenses/MIT'
                    distribution 'repo'
                }
            }
            scm {
                url 'https://github.com/navybk/netatmo-java-api'
                connection 'scm:git:git://github.com/navybk/netatmo-java-api.git'
                developerConnection 'scm:git:ssh://git@github.com/navybk/netatmo-java-api.git'
            }
            developers {
                developer {
                    name 'navybk'
                }
            }
        }
    }
}

model {
    tasks.generatePomFileForMavenJavaPublication {
        destination = file("$buildDir/generated-pom.xml")
    }
    tasks.publishMavenJavaPublicationToMavenLocal {
        dependsOn project.tasks.signArchives
    }
    tasks.publishMavenJavaPublicationToMavenRepository {
        dependsOn project.tasks.signArchives
    }
}