build.gradle

plugins {
    id 'java'
    id 'java-library'
    id 'maven-publish'
    id 'signing'
    id 'org.jreleaser' version '1.24.0'
}

apply from: 'dependencies.gradle'
apply from: 'gradle/repositories.gradle'

// VERSION STRATEGY
//
// Manual version management - update this for each release
// Format: MAJOR.MINOR.PATCH for releases, MAJOR.MINOR.PATCH-SNAPSHOT for development
//
// Example: 0.1.0-SNAPSHOT for development, 0.1.0 for release
//
// DO NOT FORGET TO DOCUMENT CHANGES IN CHANGELOG.md (create if needed)
//
def otto_config_version = "0.1.7"  // <--- SET AND UPDATE VERSION HERE

group = 'de.otto.config'
version = otto_config_version

apply from: 'gradle/maven.gradle'

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

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

    // Spring dependencies as compileOnly
    compileOnly "org.springframework:spring-context:${springContextVersion}"
    compileOnly "org.springframework.boot:spring-boot-autoconfigure:${springBootVersion}"

    // Helidon dependencies as compileOnly
    compileOnly "io.helidon.microprofile.scheduling:helidon-microprofile-scheduling:${helidonVersion}"
    compileOnly "io.helidon.config:helidon-config:${helidonVersion}"

    // Add Spring Boot testing starter
    testImplementation "org.springframework.boot:spring-boot-starter-test:${springBootVersion}"

    // Other dependencies
    implementation "software.amazon.awssdk:sts:${awsSdkVersion}"
    api "software.amazon.awssdk:appconfigdata:${awsSdkVersion}"
    api "software.amazon.awssdk:secretsmanager:${awsSdkVersion}"
    api "software.amazon.awssdk:ssm:${awsSdkVersion}"
    api "software.amazon.awssdk:sqs:${awsSdkVersion}"
    api "com.google.guava:guava:33.1.0-jre"
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.2'
    
    // Testing dependencies
    testImplementation "org.junit.jupiter:junit-jupiter-api:${junit5Version}"
    testImplementation "org.junit.jupiter:junit-jupiter-params:${junit5Version}"
    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junit5Version}"
    testRuntimeOnly "org.junit.platform:junit-platform-launcher"

    testImplementation "org.mockito:mockito-core:5.11.0"
    testImplementation "org.hamcrest:hamcrest:${hamcrestVersion}"

    testImplementation "io.helidon.config:helidon-config:${helidonVersion}"
    testImplementation "io.helidon.microprofile.testing:helidon-microprofile-testing-junit5:${helidonVersion}"
	testImplementation "io.helidon.microprofile.testing:helidon-microprofile-testing-mocking:${helidonVersion}"
}

jar {
    archiveBaseName = "${rootProject.name}"
    archiveVersion = "${project.version}"
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

tasks.register('delombok') {
    description 'Delomboks the source code'
    ant.taskdef(classname: 'lombok.delombok.ant.Tasks$Delombok',
            classpath:  configurations.compileClasspath.asPath,
            name: 'delombok')
    ant.delombok(verbose: 'true',
            encoding: 'UTF-8',
            to: 'build/delombok',
            from: 'src/')
}

test {
    useJUnitPlatform()
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            
            pom {
                name = 'Otto Config'
                description = 'Configuration library for AWS AppConfig, Secrets Manager, and Parameter Store integration'
                url = 'https://github.com/otto-de/otto-config'
                
                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }
                
                developers {
                    developer {
                        id = 'otto-de'
                        name = 'Otto GmbH & Co KG'
                    }
                }
                
                scm {
                    connection = 'scm:git:https://github.com/otto-de/otto-config.git'
                    developerConnection = 'scm:git:ssh://github.com/otto-de/otto-config.git'
                    url = 'https://github.com/otto-de/otto-config'
                }
            }
        }
    }
    
    repositories {
        maven {
            name = 'GitHubPackages'
            url = uri("https://maven.pkg.github.com/otto-de/otto-config")
            credentials {
                username = System.getenv("GITHUB_ACTOR") ?: findProperty("gpr.user")
                password = System.getenv("GITHUB_TOKEN") ?: findProperty("gpr.token")
            }
        }
        maven {
            name = 'MavenCentral'
            url = uri("https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/")
            credentials {
                username = System.getenv("MAVENCENTRAL_USERNAME") ?: findProperty("mavenCentral.username")
                password = System.getenv("MAVENCENTRAL_PASSWORD") ?: findProperty("mavenCentral.password")
            }
        }
        maven {
            name = 'staging'
            // Publish to local staging directory for JReleaser to upload
            url = layout.buildDirectory.dir('staging-deploy')
        }
    }
}

jreleaser {
    release {
        github {
            update {
                enabled = true
            }
        }
    }
    project {
        snapshot {
            fullChangelog = true
        }
    }
    gitRootSearch = true
    signing {
        active = 'ALWAYS'
        armored = true
        verify = false  // Don't require public key - JReleaser will extract it from secret key
        publicKey = System.getenv('JRELEASER_GPG_PUBLIC_KEY') ?: ''
        secretKey = System.getenv('JRELEASER_GPG_SECRET_KEY') ?: ''
        passphrase = System.getenv('JRELEASER_GPG_PASSPHRASE') ?: ''
    }
    deploy {
        maven {
            github {
                app {
                    snapshotSupported = true
                    active = System.getenv('JRELEASER_DEPLOY_MAVEN_GITHUB_ACTIVE') ?: 'ALWAYS'
                    url = "https://maven.pkg.github.com/otto-de/otto-config"
                    stagingRepository('build/staging-deploy')
                }
            }
            mavenCentral {
                app {
                    snapshotSupported = false
                    active = System.getenv('JRELEASER_DEPLOY_MAVEN_MAVENCENTRAL_ACTIVE') ?: 'ALWAYS'
                    url = 'https://central.sonatype.com/api/v1/publisher'
                    stagingRepository('build/staging-deploy')
                    retryDelay = 10
                    maxRetries = 240
                }
            }
        }
    }
}

signing {
    def signingKey = findProperty("signingKey") ?: System.getenv("GPG_SIGNING_KEY")
    def signingPassword = findProperty("signingPassword") ?: System.getenv("GPG_SIGNING_PASSWORD")
    if (signingKey && signingPassword) {
        useInMemoryPgpKeys(signingKey, signingPassword)
        sign publishing.publications.mavenJava
    } else {
        // JReleaser will handle signing if Gradle signing is not configured
        logger.warn("Gradle signing not configured - JReleaser will handle signing")
    }
}

subprojects {
    apply plugin: 'java'

    dependencies {
        // Common dependencies can be declared here
    }
}