build.gradle

plugins {
    id "com.gradle.plugin-publish" version "1.3.1"
    id 'signing' // Required for Maven Central
    id 'io.github.gradle-nexus.publish-plugin' version '2.0.0' // Automates Sonatype Nexus publishing
}

apply plugin: 'java'
apply plugin: 'maven-publish'

apply from: "${buildscript.sourceFile.parentFile}/scripts/VersionNumber.gradle"
apply from: "${buildscript.sourceFile.parentFile}/scripts/javapreprocessor.gradle"

group = 'de.inetsoftware'

def LIB_GRADLE_VERSION = System.getenv('LIB_GRADLE_VERSION') ?: '8.1.0'     // Gradle version for the wrapper

wrapper.gradleVersion = LIB_GRADLE_VERSION
def gVersion = VersionNumber.parse( gradle.gradleVersion )
println 'Gradle version: ' + gVersion

// Load version from gradle.properties file directly
def propertiesFile = file("${project.projectDir}/gradle.properties")
def versionProperty = '8.4.23'
def isSnapshot = false

if (propertiesFile.exists()) {
    def props = new Properties()
    propertiesFile.withInputStream { props.load(it) }
    versionProperty = props.getProperty('version', '8.4.23')
}

def baseVersionFromProps = versionProperty.split('-')[0]  // Remove -SNAPSHOT if present
isSnapshot = versionProperty.contains('-SNAPSHOT')

// Fetch version mapping script to validate/adjust version based on Gradle version
apply from: "${buildscript.sourceFile.parentFile}/scripts/SetupBuilderVersion.gradle"
def expectedBaseVersion = setupBuilderVersion('0').split('\\.')[0..1].join('.')  // Get major.minor (e.g., "8.4")
def actualBaseVersion = baseVersionFromProps.split('\\.')[0..1].join('.')  // Get major.minor from properties

// Extract build number (patch version) from gradle.properties version
def buildNumber = baseVersionFromProps.split('\\.')[2] ?: '0'

// Validate version compatibility with Gradle version
if (actualBaseVersion != expectedBaseVersion) {
    println "WARNING: Version in gradle.properties (${actualBaseVersion}) doesn't match expected version for Gradle ${gradle.gradleVersion} (${expectedBaseVersion})"
    println "Adjusting version to match Gradle compatibility..."
    version = "${expectedBaseVersion}.${buildNumber}" + (isSnapshot ? '-SNAPSHOT' : '')
} else {
    version = versionProperty
}

def baseVersion = "${actualBaseVersion}.${buildNumber}"
println 'SetupBuilder version: ' + version

java.sourceCompatibility = 1.8
compileJava.options.encoding = 'UTF-8'

repositories {
    mavenCentral()
}

dependencies {
    api gradleApi()
    
    // Test dependencies
    testImplementation 'junit:junit:4.13.2'
    testImplementation 'org.hamcrest:hamcrest-core:2.2'
}

sourceSets {
    main {
        java {
            srcDirs = ['src']
            srcDirs = ["${buildDir}/preparedSrc-${gVersion}"]
            exclude '**/test/**'  // Exclude test files from main source set
        }
        resources {
            srcDirs = ['src']
            exclude '**/*.java'
            exclude '**/package.html'
            exclude '**/test/**'  // Exclude test files from resources
        }
    }
    test {
        java {
            srcDirs = ['src/test']
        }
    }
}

/* Configure JPP - exclude test files */
JPP.setJPPSources( "src", [
    "gradleVersion" : "${gVersion}",
    "outputDirectory" : "${buildDir}/preparedSrc-${gVersion}"
]);

// Configure publishing
// - Snapshots: Published to Sonatype snapshot repository
// - Releases: Published to Sonatype staging repository (then closed and released)
// - Local development: Use `./gradlew publishToMavenLocal` to publish to mavenLocal()
publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            
            pom {
                name = 'Gradle Setup Builder Plugin'
                description = 'The Setup Builder is a plugin for Gradle which can create native setups for different platforms like Windows, Linux and OSX.'
                url = 'https://github.com/i-net-software/SetupBuilder'
                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }
                developers {
                    developer {
                        id = 'inetsoftware'
                        name = 'i-net software'
                    }
                }
                scm {
                    connection = 'scm:git:git://github.com/i-net-software/SetupBuilder.git'
                    developerConnection = 'scm:git:ssh://github.com/i-net-software/SetupBuilder.git'
                    url = 'https://github.com/i-net-software/SetupBuilder'
                }
            }
        }
    }
    
    // For local development, use mavenLocal()
    repositories {
        mavenLocal()
    }
}

println "Publishing version: ${version}"
println "Note: For local development, use './gradlew publishToMavenLocal'"
println "      For snapshots, use './gradlew publishToSonatype' (requires Sonatype credentials)"
println "      Snapshots are available at: https://oss.sonatype.org/content/repositories/snapshots/"

// Configure Nexus Publish Plugin for Sonatype/Maven Central
// Configure for both snapshots and releases
// Snapshots go to: https://oss.sonatype.org/content/repositories/snapshots/
// Releases go to staging, then are closed and released to Maven Central
nexusPublishing {
        repositories {
            sonatype {
                // New Central Portal URLs
                nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
                snapshotRepositoryUrl.set(uri("https://central.sonatype.com/repository/maven-snapshots/"))
                // Credentials - try both property name variations
                username.set(
                    project.findProperty('ossrhUsername') 
                        ?: project.findProperty('sonatypeUsername')
                        ?: System.getenv('SONATYPE_USERNAME') 
                        ?: System.getenv('OSSRH_USERNAME')
                        ?: ""
                )
                password.set(
                    project.findProperty('ossrhPassword')
                        ?: project.findProperty('sonatypePassword')
                        ?: System.getenv('SONATYPE_PASSWORD')
                        ?: System.getenv('OSSRH_PASSWORD')
                        ?: ""
                )
                // Staging profile ID - should be the UUID from Sonatype, not the domain
                // Get it from: https://central.sonatype.com/ -> Staging Profiles
                // Or leave it out to auto-detect by groupId
                // If you have a staging profile UUID, uncomment and set it:
                // stagingProfileId.set('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
            }
        }
    
    // Configure closeStagingRepositories task (only for releases, not snapshots)
    closeStagingRepositories {
        closeStagingRepositories.dependsOn 'publishToSonatype'
        // Only close staging for releases (non-snapshot versions)
        onlyIf { !version.toString().endsWith('-SNAPSHOT') }
    }
    
    // For snapshots, just publish (don't close staging)
    // For releases, close and release staging repositories
    if (!version.toString().endsWith('-SNAPSHOT')) {
        publish.finalizedBy 'closeStagingRepositories'
    }
}

// Configure signing for Maven Central
// Sign both snapshots and releases when credentials are available
// Note: Signing is only required for Maven Central, not for mavenLocal()
def hasSigningKey = (System.getenv('SIGNING_KEY') != null || project.findProperty('signing.key') != null)
def isPublishingToMavenLocal = gradle.startParameter.taskNames.any { 
    it.contains('MavenLocal') || it.contains('mavenLocal')
}

if (!isPublishingToMavenLocal && hasSigningKey) {
    // Only sign when publishing to Sonatype and signing key is available
    signing {
        required { true }
        useInMemoryPgpKeys( 
            System.getenv('SIGNING_KEY') ?: project.findProperty('signing.key'), 
            System.getenv('SIGNING_PASSWORD') ?: project.findProperty('signing.password') 
        )
        sign publishing.publications.mavenJava
    }
} else {
    // Skip signing for mavenLocal
    signing {
        required { false }
    }
}

javadoc {
    // Third party libs
    exclude "**/image4j"
    exclude "**/icns"
}

gradlePlugin {
    website = 'https://github.com/i-net-software/SetupBuilder'
    vcsUrl = 'https://github.com/i-net-software/SetupBuilder'

    plugins {
        setupBuilderPlugin {
            id = 'de.inetsoftware.setupbuilder'
            implementationClass = 'com.inet.gradle.setup.SetupBuilderPlugin'
            displayName = 'Gradle Setup Builder plugin'
            description = 'The Setup Builder is a plugin for Gradle which can create native setups for different platforms like Windows, Linux and OSX. The output is a *.msi, a *.deb, a *.rpm or a *.dmg file.'
            tags.set( ['setup', 'installer', 'msi', 'dmg', 'deb', 'rpm', 'windows', 'linux', 'osx' ] )
        }
        appBundlerPlugin {
            id = 'de.inetsoftware.appbundler'
            implementationClass = 'com.inet.gradle.appbundler.AppBundlerPlugin'
            description = 'Create a Java bundled application for OSX'
            displayName = 'Gradle Application Bundler plugin for OSX'
            tags.set( ['app'] )
        }
    }
}

// see https://discuss.gradle.org/t/add-apikey-and-apisecret-to-pluginbundle-extension-for-plugin-publish-plugin/8636/3
task setupPluginUpload {

    publishPlugins.dependsOn 'setupPluginUpload'
    doLast {
        def key=System.env.gradlePublishKey
        def secret = System.env.gradlePublishSecret

        if( !key || !secret)
        {
            throw new RuntimeException("gradlePublishKey and/or gradlePublishSecret are not defined environment variables")
        }

        System.properties.setProperty("gradle.publish.key", key)
        System.properties.setProperty("gradle.publish.secret", secret)
    }
}

// Check for the current operating system to load the specific build task
import org.apache.tools.ant.taskdefs.condition.Os
def dependingTask = 'deb'
if (Os.isFamily(Os.FAMILY_MAC)) {
    dependingTask = 'dmg'
} else if (Os.isFamily(Os.FAMILY_WINDOWS)) {
    dependingTask = 'msi'
}

// run the following task as a dependency to the "check"-task.
task runSetupBuilderTestTasks(type: GradleBuild) {
    check.dependsOn runSetupBuilderTestTasks
    dir = file('testBuilds')
    tasks = ['clean', dependingTask]
    
    // Only run if test or check tasks are explicitly requested (not as dependencies)
    // AND not in CI environment (testBuilds has environment-specific requirements:
    // - macOS: needs Java 8 for DMG builds
    // - Windows: needs Java in specific path for MSI builds
    // - Linux: needs deb/rpm build tools)
    onlyIf {
        def requestedTasks = project.gradle.startParameter.taskNames
        def isRequested = requestedTasks.contains('test') || requestedTasks.contains('check')
        
        // Detect CI environment (GitHub Actions, Jenkins, Travis, etc.)
        // GitHub Actions sets CI=true and GITHUB_ACTIONS=true
        def isCI = System.getenv('CI') != null || 
                   System.getenv('GITHUB_ACTIONS') != null ||
                   System.getenv('JENKINS_URL') != null ||
                   System.getenv('TRAVIS') != null
        
        return isRequested && !isCI
    }
}

afterEvaluate {
    // The first one ususally wins.
    project.tasks.withType( Copy ).all {
        println "Setting Duplication Strategy in afterEvaluate: ${it}"
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    }

    // The first one ususally wins.
    project.tasks.withType( Jar ).all {
        println "Setting Duplication Strategy in afterEvaluate: ${it}"
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    }
}

// hack the Eclipse .classpath file
apply plugin: 'eclipse'
eclipse {
    classpath {
        file {
            whenMerged { classpath ->
                // Entferne Ressourcen-Einträge, die falsch gesetzt wurden
                classpath.entries.removeAll { entry ->
                    if ( entry.kind == 'src' ) {
                        entry.excludes = []
                        entry.path.contains( 'preparedSrc' )
                    }
                }
            }
        }
    }
}