build.gradle

/*
 * PerlOnJava Build Configuration
 * This Gradle build script configures the build process for the PerlOnJava project
 */

buildscript {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }
}

// Core plugins configuration
plugins {
    id 'java'
    // Plugin for updating version catalog with latest versions (configuration cache compatible!)
    alias(libs.plugins.version.catalog.update)
    id 'application'
    // Plugin for creating OS packages (deb)
    alias(libs.plugins.ospackage)
    // Plugin for creating fat/uber JARs
    alias(libs.plugins.shadow)
    // Plugin for generating CycloneDX SBOM (Software Bill of Materials)
    alias(libs.plugins.cyclonedx)
}

// Main application class configuration
application {
    mainClass = 'org.perlonjava.app.cli.Main'
}

// Debian package build dependency
tasks.buildDeb {
    dependsOn installDist
}

// Copy custom wrapper scripts to installDist bin directory
tasks.register('copyWrapperScripts', Copy) {
    dependsOn installDist
    from(projectDir) {
        include 'jperl'
        include 'jperl.bat'
        include 'jcpan'
        include 'jcpan.bat'
        include 'jperldoc'
        include 'jperldoc.bat'
        include 'jprove'
        include 'jprove.bat'
    }
    into "${buildDir}/install/perlonjava/bin"
}

// Copy Perl bin scripts (cpan, perldoc, prove) to installDist bin directory
tasks.register('copyPerlBinScripts', Copy) {
    dependsOn installDist
    from('src/main/perl/bin') {
        include 'cpan'
        include 'perldoc'
        include 'prove'
    }
    into "${buildDir}/install/perlonjava/bin"
}

// Make buildDeb depend on both copy tasks
tasks.buildDeb {
    dependsOn copyWrapperScripts
    dependsOn copyPerlBinScripts
}

// Project metadata
group = 'org.perlonjava'
version = '5.42.0'

// CycloneDX SBOM generation configuration
cyclonedxBom {
    projectType = "application"
    schemaVersion = "1.5"
    includeLicenseText = false
    includeBomSerialNumber = true
    outputName = "bom"
    outputFormat = "all"  // Generate both JSON and XML
    componentName = "perlonjava"
    componentVersion = project.version
    organizationalEntity { oe ->
        oe.name = "PerlOnJava Project"
        oe.urls = ["https://github.com/fglock/PerlOnJava"]
    }
}

// Git info injection - injects commit ID and date into Configuration.java before compilation
// This ensures the built JAR contains accurate version information for -v output
def configFilePath = layout.projectDirectory.file('src/main/java/org/perlonjava/core/Configuration.java')

tasks.register('injectGitInfo') {
    description = 'Injects git commit info into Configuration.java'
    group = 'build'
    
    // Declare inputs/outputs for configuration cache compatibility
    def configFile = configFilePath.asFile
    
    doLast {
        if (!configFile.exists()) {
            logger.warn("Configuration.java not found, skipping git info injection")
            return
        }
        
        // Get git commit info using Runtime.exec
        def gitCommitId = 'dev'
        def gitCommitDate = 'unknown'
        
        try {
            def commitIdProcess = ['git', 'rev-parse', '--short', 'HEAD'].execute()
            commitIdProcess.waitFor()
            if (commitIdProcess.exitValue() == 0) {
                gitCommitId = commitIdProcess.text.trim()
            }
            
            def commitDateProcess = ['git', 'log', '-1', '--format=%cs', 'HEAD'].execute()
            commitDateProcess.waitFor()
            if (commitDateProcess.exitValue() == 0) {
                gitCommitDate = commitDateProcess.text.trim()
            }
        } catch (Exception e) {
            logger.warn("Could not get git info: ${e.message}")
        }
        
        // Only update if we got valid values
        if (gitCommitId && gitCommitId != 'dev') {
            def content = configFile.text
            
            // Use safe pattern matching for quoted string values
            content = content.replaceAll(
                /(gitCommitId\s*=\s*)"[^"]*"/,
                "\$1\"${gitCommitId}\""
            )
            content = content.replaceAll(
                /(gitCommitDate\s*=\s*)"[^"]*"/,
                "\$1\"${gitCommitDate}\""
            )

            // Generate build timestamp in Perl 5 "Compiled at" format: "Mon DD YYYY HH:MM:SS"
            def now = new java.util.Date()
            def buildTimestamp = new java.text.SimpleDateFormat("MMM dd yyyy HH:mm:ss", java.util.Locale.ENGLISH).format(now)
            // Perl uses single-digit day with leading space (e.g., "Apr  7" not "Apr 07")
            buildTimestamp = buildTimestamp.replaceAll(/^(\w{3}) 0/, '$1  ')
            content = content.replaceAll(
                /(buildTimestamp\s*=\s*)"[^"]*"/,
                "\$1\"${buildTimestamp}\""
            )
            
            configFile.text = content
            logger.lifecycle("Injected git info: ${gitCommitId} (${gitCommitDate})")
        }
    }
}

// Make compilation depend on git info injection
tasks.named('compileJava') {
    dependsOn 'injectGitInfo'
}

// OS package configuration for Debian packaging
ospackage {
    packageName = 'perlonjava'
    version = project.version
    maintainer = 'Flavio Soibelmann Glock <fglock@gmail.com>'
    // Java 22+ is required at runtime (any distribution: Oracle, Azul, Temurin, OpenJDK, etc.)

    into '/opt/perlonjava'
    from('build/install/perlonjava') {
        into '/opt/perlonjava'
    }
    
    // Include combined SBOM in the package
    from('build/reports') {
        into '/opt/perlonjava/share/sbom'
        include 'sbom.json'
    }

    link('/usr/local/bin/jperl', '/opt/perlonjava/bin/jperl')
    link('/usr/local/bin/jcpan', '/opt/perlonjava/bin/jcpan')
    link('/usr/local/bin/jperldoc', '/opt/perlonjava/bin/jperldoc')
    link('/usr/local/bin/jprove', '/opt/perlonjava/bin/jprove')
}

// Java toolchain configuration - requires Java 22 (for FFM API)
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(22)
    }
}

// Repository configuration
repositories {
    mavenCentral()
}

// Project dependencies
dependencies {
    // Core dependencies
    implementation libs.asm                           // ByteCode manipulation
    implementation libs.asm.util                      // ASM utilities
    implementation libs.icu4j                         // Unicode support
    implementation libs.fastjson2                     // JSON processing
    implementation libs.snakeyaml.engine              // YAML processing
    implementation libs.tomlj                         // TOML processing
    implementation libs.commons.csv                   // CSV processing
    implementation libs.sqlite.jdbc                    // SQLite JDBC driver
    // JNR-POSIX removed - using Java FFM API for native access (Java 22+)

    // Testing dependencies
    testImplementation libs.junit.jupiter.api
    testImplementation libs.junit.jupiter.engine
    testImplementation libs.junit.jupiter.params
}

// JUnit configuration
testing {
    suites {
        test {
            useJUnitJupiter()
        }
    }
}

// Java compilation settings
tasks.withType(JavaCompile).configureEach {
    options.compilerArgs << '-Xlint:-options'
    options.compilerArgs << '-Xlint:deprecation'
}

// Test execution configuration with native access
tasks.withType(Test).configureEach {
    jvmArgs += '--enable-native-access=ALL-UNNAMED'
}

// Enable native access for all Java execution tasks
allprojects {
    tasks.withType(JavaExec).configureEach {
        jvmArgs += '--enable-native-access=ALL-UNNAMED'
    }
}

// JUnit platform configuration - default test task runs only unit tests
test {
    useJUnitPlatform {
        includeTags 'unit'
        excludeTags 'full'
    }
}

// Fast unit tests only (tests in unit/ directory)
tasks.register('testUnit', Test) {
    description = 'Runs fast unit tests only (from unit/ directory)'
    group = 'verification'
    
    useJUnitPlatform {
        includeTags 'unit'
        excludeTags 'full'
    }
    
    shouldRunAfter test
}

// All tests including comprehensive module tests
tasks.register('testAll', Test) {
    description = 'Runs all tests including comprehensive module tests'
    group = 'verification'
    
    useJUnitPlatform {
        includeTags 'full'
    }
    
    shouldRunAfter testUnit
}

// Bundled module tests (XML::Parser, etc.)
// Tests live under src/test/resources/module/{ModuleName}/t/
tasks.register('testModule', Test) {
    description = 'Runs bundled CPAN module tests (e.g. XML::Parser)'
    group = 'verification'
    
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
    
    useJUnitPlatform {
        includeTags 'module'
    }
    
    shouldRunAfter testUnit
}

// Shadow JAR configuration for creating standalone executable
shadowJar {
    archiveClassifier.set('')
    destinationDirectory = file("$buildDir/../target")
    manifest {
        attributes 'Main-Class': 'org.perlonjava.app.cli.Main'
    }
    exclude 'module-info.class'
    exclude 'META-INF/MANIFEST.MF'
    
    // Include combined SBOM in JAR's META-INF/sbom/ directory
    from("$buildDir/reports/sbom.json") {
        into 'META-INF/sbom'
    }
}

// Task to generate Perl SBOM
tasks.register('generatePerlSbom', Exec) {
    description = 'Generate SBOM for bundled Perl modules'
    group = 'sbom'
    
    workingDir = projectDir
    commandLine 'bash', '-c', 
        "mkdir -p build/reports && perl dev/tools/generate-perl-sbom.pl > build/reports/perl-bom.json"
    
    // Declare output so Gradle waits for completion
    outputs.file("build/reports/perl-bom.json")
}

// Task to merge Java and Perl SBOMs
tasks.register('mergeSbom', Exec) {
    description = 'Merge Java and Perl SBOMs into combined SBOM'
    group = 'sbom'
    dependsOn cyclonedxBom, generatePerlSbom
    
    // Declare inputs so Gradle knows dependencies
    inputs.file("build/reports/bom.json")
    inputs.file("build/reports/perl-bom.json")
    
    workingDir = projectDir
    commandLine 'bash', '-c',
        "perl dev/tools/merge-sbom.pl build/reports/bom.json build/reports/perl-bom.json > build/reports/sbom.json"
    
    // Declare output
    outputs.file("build/reports/sbom.json")
}

// Ensure combined SBOM is generated before shadowJar
shadowJar.dependsOn mergeSbom

// Make shadowJar part of the build process
tasks.named('build') {
    dependsOn shadowJar
}

// Source sets configuration for including Perl resources
sourceSets {
    main {
        resources {
            srcDir 'src/main/perl'
            srcDir 'src/main/resources'
            include '**/*.pm'
            include '**/*.pl'
            include '**/*.ph'
            include '**/*.pod'
            include '**/*.dd'
            include '**/*.yml'
            include '**/media.types'
            include 'lib/ExtUtils/xsubpp'
            include 'bin/**'
            include 'META-INF/services/**'
        }
    }
    test {
        resources {
            srcDir 'src/test/resources'
        }
    }
}

// Resource processing configuration
tasks.named('processResources', Copy) {
    from(sourceSets.main.resources.srcDirs) {
        include '**/*.pm'
        include '**/*.ph'
        include '**/*.pod'
        include '**/*.dd'
        include '**/*.yml'
        include '**/media.types'
        include 'bin/**'
        include 'META-INF/services/**'
    }
    into("$buildDir/resources/main")
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

// Test resource processing configuration
tasks.named('processTestResources', Copy) {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

// Parallel test execution tasks
// Run with: ./gradlew testUnitParallel --parallel
def parallelShards = 4

(0..<parallelShards).each { index ->
    tasks.register("testUnitShard${index}", Test) {
        group = 'verification'
        description = "Runs shard ${index} of ${parallelShards} of unit tests"
        
        useJUnitPlatform {
            includeTags 'unit'
            excludeTags 'full'
        }
        
        systemProperty 'test.shard.index', index
        systemProperty 'test.shard.total', parallelShards
        
        testClassesDirs = sourceSets.test.output.classesDirs
        classpath = sourceSets.test.runtimeClasspath
    }
}

tasks.register('testUnitParallel') {
    group = 'verification'
    description = 'Runs unit tests in parallel across multiple JVMs. Usage: gradle testUnitParallel --parallel'
    dependsOn 'testUnitShard0', 'testUnitShard1', 'testUnitShard2', 'testUnitShard3'
}

// Version catalog update configuration
// The nl.littlerobots.version-catalog-update plugin is configuration cache compatible!
// Use: ./gradlew versionCatalogUpdate to check and update dependencies
// Use: ./gradlew versionCatalogUpdate --interactive to review changes interactively
versionCatalogUpdate {
    // Sort the catalog keys
    sortByKey = true
    // Keep versions not used in the project
    keep {
        keepUnusedVersions = true
    }
    // Pin cyclonedx plugin to current 2.x version.
    //
    // cyclonedx 3.x is NOT compatible with this build for four reasons:
    //   1. schemaVersion changed from string "1.5" to enum "VERSION_15"
    //   2. outputName/outputFormat properties were removed; output is now
    //      configured via jsonOutput/xmlOutput file properties, and the
    //      default path moved from build/reports/bom.json to
    //      build/reports/cyclonedx/bom.json (breaks the mergeSbom task)
    //   3. organizationalEntity closure API was removed from the aggregate
    //      task (CyclonedxAggregateTask)
    //   4. Gradle 9.x triggers "No XmlService implementation found" at
    //      runtime due to a missing Maven API dependency in the plugin
    //
    // To unpin: upgrade Gradle first, then adapt the cyclonedxBom block
    // and mergeSbom input path above to the 3.x API. See:
    //   https://github.com/CycloneDX/cyclonedx-gradle-plugin (v3 README)
    //
    // Pin shadow to 9.3.x - shadow 9.4.x introduces a classpath conflict
    // that triggers "No XmlService implementation found" from the cyclonedx
    // plugin. Unpin after cyclonedx is upgraded to 3.x.
    pin {
        plugins = [libs.plugins.cyclonedx, libs.plugins.shadow]
    }
}