build.gradle

plugins {
    alias libs.plugins.managedversioning
    id 'test-report-aggregation'
    id 'java-library'
    id 'opensesame.publishing'
}

java.withJavadocJar()
java.withSourcesJar()

managedVersioning {
    versionFile.set rootProject.file('version.properties')
    versionPRs()
    versionSnapshots()

    gitHubActions {
        release {
            prettyName = 'Release'
            workflowDispatch = true
            gradleJob {
                name = 'build'
                permissions.put 'packages', 'read'
                secret('GITHUB_TOKEN')
                setupGitUser()
                readOnly = false
                gradlew 'Tag Release', 'tagRelease'
                gradlew 'Build', 'build'
                push()
                recordVersion 'Record Version', 'version'
                dependencySubmission()
            }
            gradleJob {
                name.set 'publishCentral'
                permissions.put 'packages', 'read'
                secret('GITHUB_TOKEN')
                buildCache()
                needs.add('build')
                gradlew 'Publish', 'publishCentral', 'closeAndReleaseSonatypeStagingRepository'
                tag.set('${{needs.build.outputs.version}}')
                sign()
                mavenCentral()
            }
            gradleJob {
                name.set 'publishPlugins'
                permissions.put 'packages', 'read'
                secret('GITHUB_TOKEN')
                buildCache()
                needs.add('build')
                gradlew 'Publish Plugins', 'publishPlugins'
                tag.set('${{needs.build.outputs.version}}')
                sign()
                pluginPortal()
            }
        }

        def testOnBuild = { dev.lukebemish.managedversioning.actions.GradleJob job ->
            job.gradlew 'Assemble', 'assemble', ':opensesame-natives:setupTestEnvironment'
            job.upload('natives-test-environment', ['natives/build/testEnvironment/*']) {
                requiredSteps.add 'assemble'
                with.put('retention-days', '1')
            }
            job.gradlew 'Test', 'check', '--continue'
            job.gradlew('Test Plugin', ['check', '--continue']) {
                workingDirectory.set './testplugin'
                runsOnError.set true
                requiredSteps.add 'assemble'
            }
            job.upload('junit-test-results-gradle', ['**/build/test-results/*/TEST-*.xml']) {
                runsOnError.set true
                requiredSteps.add 'assemble'
                with.put('retention-days', '1')
            }
        }

        def nativeTest = { dev.lukebemish.managedversioning.actions.GitHubAction action ->
            action.job {
                def strategy = [:]
                strategy['fail-fast'] = false
                def matrix = [:]
                strategy.matrix = matrix
                matrix.os = ['linux', 'windows', 'macos']
                // We're giving up on testing on x32 systems (windows or linux) because it's too much of a hassle -- we'd probably need custom JDK builds at some point...
                matrix.arch = ['x86_64', 'aarch64', 'arm']
                matrix.exclude = [
                        // No natives
                        [os: 'macos', arch: 'i386'],
                        [os: 'macos', arch: 'arm'],
                        [os: 'windows', arch: 'arm'],

                        // No way to test at present
                        [os: 'windows', arch: 'aarch64'],
                        [os: 'macos', arch: 'x86_64'],
                        [os: 'linux', arch: 'arm']
                ]
                matrix.include = [
                        [os: 'macos', runner: 'macos-latest', java_home: '$JAVA_HOME_17_arm64'],
                        [os: 'windows', runner: 'windows-latest', java_home: '$JAVA_HOME_17_X64'],
                        [os: 'linux', runner: 'ubuntu-latest', java_home: '$JAVA_HOME_17_X64'],

                        [os: 'linux', arch: 'aarch64', qemu: 'arm64', docker_arch: 'arm64', docker: 'arm64v8/eclipse-temurin:17'],
                ]
                parameters.put('strategy', strategy)
                name.set 'natives-test'
                needs.add('build')
                runsOn.set('${{ matrix.runner }}')
                step {
                    name.set 'Download Artifact'
                    id.set 'download'
                    uses.set 'actions/download-artifact@v4'
                    with.put 'name', 'natives-test-environment'
                }
                step {
                    name.set 'Setup QEMU'
                    parameters.put('if', '${{ matrix.qemu }}')
                    run.set('sudo apt-get -qq install -y qemu qemu-user-static\n' +
                            'docker run --rm --privileged multiarch/qemu-user-static --reset -p yes --credential yes')
                }
                step {
                    name.set 'Run with Docker'
                    parameters.put('if', '${{ matrix.docker }}')
                    run.set 'docker run --workdir "${GITHUB_WORKSPACE}" -v "${GITHUB_WORKSPACE}:${GITHUB_WORKSPACE}:z" --rm --platform linux/${{ matrix.docker_arch }} -t ${{ matrix.docker }} /bin/bash -c \'' +
                            'mkdir ../working; cp -r ./ ../working/; cd ../working; ' +
                            'java @args-${{ matrix.os }}.txt; return=$?; ' +
                            'cp -r ./ ${GITHUB_WORKSPACE}/; cd ${GITHUB_WORKSPACE}; exit $return\''
                }
                step {
                    name.set 'Run'
                    parameters.put('if', '${{ !matrix.qemu }}')
                    parameters.put('shell', 'bash')
                    run.set '${{ matrix.java_home }}/bin/java @args-${{ matrix.os }}.txt'
                }
                step {
                    name.set 'Upload Results'
                    runsOnError.set true
                    requiredSteps.add 'download'
                    uses.set 'actions/upload-artifact@v4'
                    with.put 'name', 'junit-test-results-native-${{ matrix.os }}-${{ matrix.arch }}'
                    with.put 'path', 'results/TEST-*.xml'
                }
            }
            action.job {
                name.set 'aggregate-test-results'
                runsOn.set 'ubuntu-latest'
                needs.add('natives-test')
                needs.add('build')
                getIf().set('always()')
                step {
                    name.set 'Download Artifact'
                    id.set 'download'
                    uses.set 'actions/download-artifact@v4'
                    with.put 'pattern', 'junit-test-results-*'
                }
                step {
                    name.set 'Upload Results'
                    uses.set 'actions/upload-artifact@v4'
                    with.put 'name', 'junit-test-results'
                    with.put 'path', '**/TEST-*.xml'
                }
            }
        }

        snapshot {
            prettyName.set 'Snapshot'
            workflowDispatch.set(true)
            onBranches.add 'main'
            gradleJob {
                buildCache()
                permissions.put 'packages', 'read'
                secret('GITHUB_TOKEN')
                name.set 'build'
                testOnBuild.call(it)
                gradlew 'Publish', 'publish'
                mavenSnapshot('github')
            }
            nativeTest.call(it)
        }
        build_pr {
            prettyName.set 'Build PR'
            pullRequest.set(true)
            gradleJob {
                name.set 'build'
                permissions.put 'packages', 'read'
                secret('GITHUB_TOKEN')
                testOnBuild.call(it)
                gradlew 'Publish', 'publish'
                pullRequestArtifact()
            }
            nativeTest.call(it)
        }
        publish_pr {
            prettyName.set 'Publish PR'
            publishPullRequestAction(
                    'github',
                    "dev/lukebemish/opensesame/opensesame-*",
                    'Build PR'
            )
        }
        report {
            prettyName.set 'Report Test Results'
            completedWorkflows.set(['Build PR', 'Snapshot'])
            job {
                name.set 'checks'
                permissions.put('contents', 'read')
                permissions.put('actions', 'read')
                permissions.put('checks', 'write')
                step {
                    name.set 'Checkout'
                    uses.set 'actions/checkout@v4'
                    with.put 'ref', '${{ github.event.workflow_run.head_commit.id }}'
                    with.put 'repository', '${{ github.event.workflow_run.head_repository.full_name }}'
                }
                step {
                    name.set 'Download Test Report'
                    uses.set 'actions/download-artifact@v4'
                    with.put 'name', 'junit-test-results'
                    with.put 'github-token', '${{ github.token }}'
                    with.put 'run-id', '${{ github.event.workflow_run.id }}'
                }
                [17, 21, 22].each { int javaVersion ->
                    step {
                        name.set 'JUnit Test Report - Java '+javaVersion
                        uses.set 'dorny/test-reporter@v1'
                        with.put 'name', 'Test Results - Java '+javaVersion
                        with.put 'path', '**/test-results/testOn'+javaVersion+'/**/TEST-*.xml'
                        with.put 'reporter', 'java-junit'
                        with.put 'fail-on-empty', 'true'
                        with.put 'list-tests', 'failed'
                        with.put 'list-suites', 'failed'
                    }
                }
                step {
                    name.set 'JUnit Test Report - Misc'
                    uses.set 'dorny/test-reporter@v1'
                    with.put 'name', 'Test Results - Misc'
                    with.put 'path', '**/test-results/test/**/TEST-*.xml,junit-test-results-native-*/**/TEST-*.xml'
                    with.put 'reporter', 'java-junit'
                    with.put 'fail-on-empty', 'true'
                    with.put 'list-tests', 'failed'
                }
            }
        }
    }
}

managedVersioning.apply()

repositories {
    mavenCentral()
    maven {
        name = 'FabricMC'
        url = 'https://maven.fabricmc.net/'
    }
    maven {
        name = 'SpongePowered'
        url = 'https://repo.spongepowered.org/maven'
    }
}

configurations {
    javadocSources {
        canBeResolved = true
    }
    javadocImplementation {
        canBeResolved = false
        canBeConsumed = false
    }
    compileOnlyApi.extendsFrom javadocImplementation
    javadocClasspath {
        canBeResolved = true
        extendsFrom javadocImplementation
    }
}

dependencies {
    subprojects.each { p ->
        if (p.name.startsWith('opensesame-')) {
            testReportAggregation p
        }
    }

    [
            'mixin',
            'core',
            'groovy'
    ].each { p ->
        javadocSources project(path: ":opensesame-$p", configuration: 'sourcesElements')
        javadocImplementation project(path: ":opensesame-$p", configuration: 'apiElements')
    }

    javadocClasspath libs.jetbrains.annotations
    javadocClasspath libs.groovy.core
}

println "Building: ${rootProject.version}"

managedVersioning.publishing.mavenCentral()

reporting {
    reports {
        testAggregateTestReport(AggregateTestReport) {
            testType = TestSuiteType.UNIT_TEST
        }
    }
}

tasks.register('unpackJavadocSources') {
    dependsOn configurations.javadocSources
    inputs.files(configurations.javadocSources)
    def destinationDir = layout.buildDirectory.dir('unpackedJavadocSources').get().asFile
    outputs.dir(destinationDir)
    doLast {
        destinationDir.deleteDir()
        copy {
            into destinationDir
            configurations.javadocSources.files.each {
                from(zipTree(it)) {
                    include('**/*.java')
                    exclude('module-info.java')
                }
            }
        }

        destinationDir.traverse {
            if (it.isDirectory()) {
                def packageInfo = it.toPath().resolve('package-info.java').toFile()
                if (packageInfo.exists()) {
                    String packageInfoContent = packageInfo.text
                    if (packageInfoContent.contains('@ApiStatus.Internal')) {
                        it.listFiles().each {
                            if (it.isFile()) {
                                it.delete()
                            }
                        }
                    }
                }
            }
        }
    }
}

tasks.named('javadoc', Javadoc).configure {
    dependsOn tasks.unpackJavadocSources
    dependsOn configurations.javadocClasspath
    inputs.files(configurations.javadocClasspath)
    inputs.files(tasks.unpackJavadocSources.outputs.files)
    destinationDir = layout.buildDirectory.dir('javadoc').get().asFile
    classpath = configurations.javadocClasspath
    source(tasks.unpackJavadocSources.outputs.files)
}

components.java.withVariantsFromConfiguration(configurations.apiElements) {
    skip()
}

components.java.withVariantsFromConfiguration(configurations.runtimeElements) {
    skip()
}

components.java.withVariantsFromConfiguration(configurations.sourcesElements) {
    skip()
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            pom {
                openSesameConvention.pomShared(it, '')
                description = 'A tool for breaking encapsulation in JVM projects'
                packaging = 'pom'
            }
        }
    }
}

tasks.named('check').configure {
    dependsOn tasks.testAggregateTestReport
}