build.gradle

import org.apache.tools.ant.filters.ReplaceTokens

import java.nio.charset.StandardCharsets

import static java.nio.charset.StandardCharsets.UTF_8

plugins {
    id 'idea'
    id 'java'
    id 'java-library'
    id 'maven-publish'
    id 'jacoco'
    id 'jvm-test-suite'
    id 'jacoco-report-aggregation'
    id 'signing'
}

group = 'io.github.honhimw'
version = '1.11.0.0' // API docs version plus '.x(-SNAPSHOT/RC.x)?'
description = 'Reactive meilisearch rest client powered by reactor-netty-http.'

def title = 'Meilisearch rest client for java'
def reactorVersion = '2023.0.11'
def jacksonVersion = '2.18.1'
def gsonVersion = '2.11.0'
def lombokVersion = '1.18.34'
def slf4jVersion = '2.0.16'

apply plugin: 'idea'
apply plugin: 'java'
apply plugin: 'java-library'
apply plugin: 'maven-publish'
apply plugin: 'jacoco'
apply plugin: 'signing'

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    implementation platform("com.fasterxml.jackson:jackson-bom:${jacksonVersion}")
    implementation platform("io.projectreactor:reactor-bom:${reactorVersion}")

    implementation "io.projectreactor.netty:reactor-netty-http"

    implementation 'com.fasterxml.jackson.core:jackson-core'
    implementation 'com.fasterxml.jackson.core:jackson-databind'
    implementation 'com.fasterxml.jackson.core:jackson-annotations'
    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jdk8'
    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'
    implementation "org.slf4j:slf4j-api:${slf4jVersion}"

    compileOnly "com.google.code.gson:gson:${gsonVersion}"

    compileOnly 'jakarta.annotation:jakarta.annotation-api:2.1.1'
    compileOnly 'com.google.code.findbugs:jsr305:3.0.2'
    compileOnly "org.projectlombok:lombok:${lombokVersion}"

    annotationProcessor "org.projectlombok:lombok:${lombokVersion}"
}

dependencies {
    testImplementation "com.google.code.gson:gson:${gsonVersion}"
    testCompileOnly 'jakarta.annotation:jakarta.annotation-api:2.1.1'
    testCompileOnly "org.projectlombok:lombok:${lombokVersion}"

    testAnnotationProcessor "org.projectlombok:lombok:${lombokVersion}"
    testImplementation 'io.projectreactor:reactor-test'
    testImplementation "org.slf4j:slf4j-simple:${slf4jVersion}"
}

java {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
    withSourcesJar()
    withJavadocJar()
}

processTestResources {
    def nm = new LinkedHashMap<String, String>()
    project.properties.forEach { k, v ->
        nm.put(k, v.toString())
    }
    nm.put('project.artifactId', project.name)
    def properties = loadProfileProperties()
    properties.forEach { k, v ->
        nm.put(String.valueOf(k), String.valueOf(v))
    }
    filter ReplaceTokens, beginToken: '#{', endToken: '}', tokens: nm
}

publishing {

    repositories {
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/honhimW/meilisearch-rest-client")
            credentials {
                username = githubProperties().getProperty("gpr.user") as String
                password = githubProperties().getProperty("gpr.key") as String
            }
        }
        maven {
            name = "sonatype-snapshots"
            url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
            credentials {
                username = sonatypeProperties().getProperty("sonatype.username") as String
                password = sonatypeProperties().getProperty("sonatype.password") as String
            }
        }
        maven {
            name = "sonatype-releases"
            url = uri("https://s01.oss.sonatype.org/content/repositories/releases/")
            credentials {
                username = sonatypeProperties().getProperty("sonatype.username") as String
                password = sonatypeProperties().getProperty("sonatype.password") as String
            }
        }
        maven {
            name = "sonatype-central"
            url = uri("https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/")
            credentials {
                username = sonatypeProperties().getProperty("sonatype.username") as String
                password = sonatypeProperties().getProperty("sonatype.password") as String
            }
        }
    }

    publications {
        create('gpr', MavenPublication) {
            from components.java
            pom {
                name.set(title)
                description.set(project.description)
                url.set("https://github.com/honhimW/meilisearch-rest-client")
                licenses {
                    license {
                        name.set('The Apache License, Version 2.0')
                        url.set('https://www.apache.org/licenses/LICENSE-2.0.txt')
                    }
                }
                developers {
                    developer {
                        name.set('honhimw')
                        email.set('honhimw@outlook.com')
                        url.set('https://honhimW.github.io')
                    }
                }
                scm {
                    connection.set('scm:git:git://github.com/honhimW/meilisearch-rest-client.git')
                    developerConnection.set('scm:git:ssh://github.com/honhimW/meilisearch-rest-client.git')
                    url.set('https://github.com/honhimW/meilisearch-rest-client')
                }
            }
        }
    }

}

signing {
    def props = sonatypeProperties()
    def keyId = props.getProperty('signing.keyId')
    def ringFile = props.getProperty('signing.secretKeyBase64')
    def password = props.getProperty('signing.password')
    if (!(keyId == null || ringFile == null || password == null)) {
        useInMemoryPgpKeys(keyId, ringFile, password)
        sign publishing.publications.gpr
    }
}

jar {
    enabled(true)
    archiveClassifier = ''
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = UTF_8.name()
    options.forkOptions.jvmArgs += ['-Duser.language=en', '-Duser.country=NO']
    inputs.files(tasks.withType(ProcessResources))
//    options.compilerArgs << "-Werror" << "-Xlint:deprecation" << "-Xlint:unchecked"
}

testing {
    suites {
        test {
            useJUnitJupiter()
            dependencies {
                implementation platform('org.junit:junit-bom:5.11.3')
            }
            targets {
                all {
                    testTask.configure {
                        testLogging {
                            events(
//                                    'passed',
                                    'skipped',
                                    'failed'
                            )
                        }
                        finalizedBy jacocoTestReport
                    }
                }
            }
        }
    }
}

jacocoTestReport {
    reports {
        xml.setRequired true
        csv.setRequired false
        html.setOutputLocation layout.buildDirectory.dir('jacocoHtml')
    }
}

tasks.register('publish-snapshot') {
    version = version + '-SNAPSHOT'
    finalizedBy ':publishAllPublicationsToSonatype-snapshotsRepository'
}
tasks.register('publish-release') {
    finalizedBy ':publishAllPublicationsToSonatype-releasesRepository'
}
tasks.register('publish-central') {
    finalizedBy ':publishAllPublicationsToSonatype-centralRepository'
}

Properties loadProfileProperties() {
    def properties = new Properties()
    properties.put('meili-search.host', '127.0.0.1')
    properties.put('meili-search.port', '7700')
    properties.put('meili-search.api-key', 'MASTER_KEY')
    properties.put('tests-index', 'movie_test')
    def file = file("profile-${findProperty('profiles.active')}.properties")
    if (file.exists()) {
        file.withInputStream { properties.load(it) }
    }
    return properties
}

Properties githubProperties() {
    def properties = new Properties()

    def file = file("github.properties")
    if (file.exists()) {
        file.withInputStream { properties.load(it) }
    }
    return properties
}

Properties sonatypeProperties() {
    def properties = new Properties()

    def file = file("sonatype.properties")
    if (file.exists()) {
        file.withInputStream { properties.load(it) }
    }
    return properties
}