build.gradle

plugins {
    id 'io.spring.dependency-management' version '1.1.7'
    id 'com.github.ben-manes.versions' version '0.54.0'
    id 'java-library'
    id 'maven-publish'
    id 'signing'
    id 'com.vanniktech.maven.publish' version '0.36.0'
    id 'net.researchgate.release' version '3.1.0'
    id 'checkstyle'
    id 'pmd'
    id 'jacoco'
}

import com.vanniktech.maven.publish.JavaLibrary
import com.vanniktech.maven.publish.JavadocJar

group = 'com.digitalsanctuary.cf.turnstile'
// version '1.1.6-SNAPSHOT'
description = 'SpringBoot Cloudflare Turnstile Library'

ext {
    springBootVersion = '4.0.6'
    lombokVersion = '1.18.46'
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

repositories {
    mavenCentral()
}

dependencies {
    // Spring Boot dependencies
    compileOnly "org.springframework.boot:spring-boot-starter-web:$springBootVersion"
    compileOnly "org.springframework.boot:spring-boot-starter-actuator:$springBootVersion"

    // Lombok dependencies
    compileOnly "org.projectlombok:lombok:$lombokVersion"
    annotationProcessor "org.springframework.boot:spring-boot-configuration-processor:$springBootVersion"
    annotationProcessor "org.projectlombok:lombok:$lombokVersion"

    // Lombok dependencies for test classes
    testCompileOnly "org.projectlombok:lombok:$lombokVersion"
    testAnnotationProcessor "org.projectlombok:lombok:$lombokVersion"
    testAnnotationProcessor "org.springframework.boot:spring-boot-configuration-processor:$springBootVersion"

    // Testing dependencies
    testImplementation "org.springframework.boot:spring-boot-starter-web:$springBootVersion"
    testImplementation "org.springframework.boot:spring-boot-starter-test:$springBootVersion"
    testImplementation "org.springframework.boot:spring-boot-starter-actuator:$springBootVersion"
    testImplementation 'org.junit.jupiter:junit-jupiter:6.0.3'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'

}

test {
    useJUnitPlatform()
}

tasks.named('jar') {
    enabled = true
    archiveBaseName.set('ds-spring-cf-turnstile')
    archiveClassifier.set('')
}

// Run tests with different JDK versions
tasks.register('testJdk17', Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(17)
    }
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
    useJUnitPlatform()
    doFirst {
        println("Running tests with JDK 17")
    }
}

tasks.register('testJdk21', Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(21)
    }
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
    useJUnitPlatform()
    doFirst {
        println("Running tests with JDK 21")
    }
}

// Task that runs both test tasks
tasks.register('testAll') {
    dependsOn(tasks.named('testJdk17'), tasks.named('testJdk21'))
}

// Ensure the default 'test' task triggers both test tasks
tasks.test {
    useJUnitPlatform()
    dependsOn(tasks.named('testAll'))
}

// Maven Central Publishing Tasks
mavenPublishing {
  configure(new JavaLibrary(new JavadocJar.Javadoc(), true))
  // publishToMavenCentral is now configured via gradle.properties
  signAllPublications()
  coordinates("com.digitalsanctuary", "ds-spring-cf-turnstile", project.version)

  pom {
    name = "Spring Cloudflare Turnstile Library"
    description = "SpringBoot Cloudflare Turnstile Library"
    inceptionYear = "2024"
    url = "https://github.com/devondragon/SpringCFTurnstile"
    licenses {
      license {
        name = "The Apache License, Version 2.0"
        url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
        distribution = "http://www.apache.org/licenses/LICENSE-2.0.txt"
      }
    }
    developers {
      developer {
        id = "devondragon"
        name = "Devon Hillard"
        url = "https://github.com/devondragon/"
      }
    }
    scm {
      url = "https://github.com/devondragon/SpringCFTurnstile"
      connection = "scm:git:git@github.com:devondragon/SpringCFTurnstile.git"
      developerConnection = "scm:git:ssh://git@github.com:devondragon/SpringCFTurnstile.git"
    }
  }
}

tasks.named("publishMavenPublicationToMavenCentralRepository") {
    dependsOn("signMavenPublication")
}

publishing {
    repositories {
        maven {
            name = 'reposiliteRepository'
            url = uri('https://reposilite.tr0n.io/private')
            credentials(PasswordCredentials)
            authentication {
                 basic(BasicAuthentication)
            }
        }
        // more repositories can go here
    }
}

// Code Quality Configurations

checkstyle {
   //  toolVersion = '10.14.2'
    configFile = project.file("config/checkstyle/checkstyle.xml")
    configProperties = [
        'baseDir': rootDir
    ]
    ignoreFailures = true
}

// Skip checkstyle if the config file doesn't exist
tasks.withType(Checkstyle) {
    def checkstyleConfigFile = project.file("config/checkstyle/checkstyle.xml")
    enabled = checkstyleConfigFile.exists()
    if (!checkstyleConfigFile.exists()) {
        logger.warn("Checkstyle config file not found at {}, skipping checkstyle tasks", checkstyleConfigFile.absolutePath)
    }
}

pmd {
    // toolVersion = '6.55.0'
    consoleOutput = true
    ruleSetFiles = files(project.file("config/pmd/ruleset.xml"))
    ruleSets = []
    ignoreFailures = true
}

// Skip PMD if the config file doesn't exist
tasks.withType(Pmd) {
    def pmdConfigFile = project.file("config/pmd/ruleset.xml")
    enabled = pmdConfigFile.exists()
    if (!pmdConfigFile.exists()) {
        logger.warn("PMD config file not found at {}, skipping PMD tasks", pmdConfigFile.absolutePath)
    }
}

jacoco {
    // toolVersion = '0.8.11'
}

jacocoTestReport {
    reports {
        xml.required = true
        html.required = true
    }
    dependsOn test
}

jacocoTestCoverageVerification {
    violationRules {
        rule {
            enabled = false
            limit {
                minimum = 0.48
            }
        }
    }
}

// Maven Publishing Aliases

tasks.register("publishReposilite") {
    dependsOn("publishMavenPublicationToReposiliteRepository")
}

tasks.register("publishMavenCentral") {
    dependsOn("publishAndReleaseToMavenCentral")
    // doFirst {
    //     project.gradle.startParameter.configurationCache = false
    // }
}

tasks.register("publishLocal") {
    dependsOn("publishToMavenLocal")
    // doFirst {
    //     project.gradle.startParameter.refreshDependencies = true
    // }
}

// Debug task to help diagnose file issues in CI
tasks.register("debugCI") {
    // Capture values at configuration time to be compatible with configuration cache
    def projectDir = project.projectDir.absolutePath
    def rootDirectory = rootDir.absolutePath
    def checkstyleFile = project.file("config/checkstyle/checkstyle.xml")
    def pmdFile = project.file("config/pmd/ruleset.xml")
    def configDir = project.file("config")

    doLast {
        println "Working directory: ${System.getProperty('user.dir')}"
        println "Project directory: ${projectDir}"
        println "Root directory: ${rootDirectory}"

        println "Checkstyle file exists: ${checkstyleFile.exists()}"
        if (checkstyleFile.exists()) {
            println "Checkstyle file path: ${checkstyleFile.absolutePath}"
        }

        println "PMD file exists: ${pmdFile.exists()}"
        if (pmdFile.exists()) {
            println "PMD file path: ${pmdFile.absolutePath}"
        }

        println "Directory contents:"
        configDir.listFiles().each { file ->
            println " - ${file.name}"
            if (file.isDirectory()) {
                file.listFiles().each { subFile ->
                    println "   - ${subFile.name}"
                }
            }
        }
    }
}

task generateAIChangelog(type: Exec) {
    def newVersion = project.version
    commandLine 'mise', 'x', '--', 'python', 'generate_changelog.py', newVersion
}

release {
    beforeReleaseBuild.dependsOn generateAIChangelog
    // afterReleaseBuild.dependsOn publishReposilite
    afterReleaseBuild.dependsOn publishMavenCentral
}