build.gradle

plugins {
    id 'java-library'
    id 'maven-publish'
    id 'io.github.gradle-nexus.publish-plugin' version "1.3.0"
    id 'com.github.johnrengelman.shadow' version '7.0.0'
    id 'signing'
}

import org.apache.tools.ant.filters.ReplaceTokens
def versionObj = new Version(major: 2, minor: 7, revision: 0)

group 'io.github.kodehawa'
version "$versionObj"
apply plugin: 'java'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.fasterxml.jackson.core:jackson-core:2.16.0'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.16.0'
    implementation 'com.squareup.okhttp3:okhttp:4.10.0'
    implementation 'org.slf4j:slf4j-api:2.0.9'

    testImplementation 'ch.qos.logback:logback-classic:1.4.14'
    testImplementation 'junit:junit:4.13.2'
}

task sourcesForRelease(type: Copy) {
    from 'src/main/java'
    into 'build/filteredSrc'
}

//Task for the versioning system
task prepareSource(type: Copy) {
    from 'src/main/java'
    into 'build/prepared-src'
    filter(ReplaceTokens, tokens: [
            version: versionObj.toString()
    ])
    dependsOn clean
}
prepareSource.dependsOn clean

// Maven Central requirement
java {
    withJavadocJar()
    withSourcesJar()
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
}

javadoc {
    failOnError = true
    options.memberLevel = JavadocMemberLevel.PUBLIC
    options.author()
    options.encoding = 'UTF-8'
}

compileJava {
    source = sourcesForRelease.destinationDir
    classpath = sourceSets.main.compileClasspath

    options.encoding = 'UTF-8'

    dependsOn sourcesForRelease
}

jar {
    archiveBaseName = project.name
    manifest {
        attributes 'Implementation-Version': archiveVersion
    }
}

shadowJar {
    classifier("withDependencies")
}

nexusPublishing {
    repositories {
        sonatype {
            nexusUrl.set(uri("https://s01.oss.sonatype.org/service/local/"))
            snapshotRepositoryUrl.set(uri("https://s01.oss.sonatype.org/content/repositories/snapshots/"))
            username = System.getenv("SONATYPE_USER")
            password = System.getenv("SONATYPE_PASS")
        }
    }
}

publishing {
    repositories {
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/kodehawa/imageboard-api")
            credentials {
                username = project.findProperty("gpr.user") ?: System.getenv("GITHUB_ACTOR")
                password = project.findProperty("gpr.key") ?: System.getenv("GITHUB_TOKEN")
            }
        }
    }

    publications {
        gpr(MavenPublication) {
            from(components.java)
        }

        mavenJava(MavenPublication) {
            from(components.java)

            pom {
                name.set("imageboard-api")
                description.set(" Simple asynchronous Java API wrapper around the most popular danbooru-compatible (Konachan, Yande.re, Danbooru, Gelbooru, etc) booru APIs. ")
                url.set("https://github.com/Kodehawa/imageboard-api")
                licenses {
                    license {
                        name.set("Apache-2.0")
                        url.set("https://www.apache.org/licenses/LICENSE-2.0")
                    }
                }
                developers {
                    developer {
                        id.set("1")
                        name.set("Kodehawa")
                        email.set("contact@mantaro.site")
                    }
                }
                scm {
                    connection.set("scm:git:git://github.com/Kodehawa/imageboard-api.git")
                    developerConnection.set("scm:git:ssh://github.com/Kodehawa/imageboard-api.git")
                    url.set("https://github.com/Kodehawa/imageboard-api")
                }
            }
        }
    }
}

signing {
    def signingKey = base64Decode(System.getenv("SIGN_KEY"))
    def signingPassword = System.getenv("SIGN_PW")
    useInMemoryPgpKeys(signingKey, signingPassword)
    sign publishing.publications.mavenJava
}

static def base64Decode(encodedString){
    if(encodedString != null) {
        byte[] decoded = encodedString.decodeBase64()
        String decode = new String(decoded)
        return decode
    }
    return null;
}

build {
    dependsOn clean
    dependsOn jar
    dependsOn javadocJar
    dependsOn sourcesJar
    dependsOn shadowJar

    dependsOn test

    jar.mustRunAfter clean
    javadocJar.mustRunAfter jar
    sourcesJar.mustRunAfter javadocJar
    shadowJar.mustRunAfter sourcesJar
}

class Version {
    String major, minor, revision

    String toString() {
        "${major}.${minor}" + (revision == "0" ? "" : ".${revision}")
    }
}