build.gradle

/*
 * Copyright (c) 2020. MobilityData IO.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
 * A note about publishing and signing.
 * Maven central requires that artifacts be signed. And upload is done via Maven Central Portal.
 * To publish you will need these environment variables defined:
 *       MAVEN_CENTRAL_PORTAL_TOKEN_USERNAME
 *       MAVEN_CENTRAL_PORTAL_TOKEN_PASSWORD
 *       MAVEN_GPG_PRIVATE_KEY
 *       MAVEN_GPG_PASSPHRASE
 * If run manually, the suggestion is to put these in a shell script with restricted read permissions,
 * then source it before calling ./gradlew
 * If run from a Github action, make sure these environment variables are defined.
 */
plugins {
    id 'java'
    id 'maven-publish'
    id 'signing'
    id 'test-report-aggregation'
    id "io.freefair.aggregate-javadoc" version "6.4.3"
    id "pl.allegro.tech.build.axion-release" version "1.15.3"
    alias(libs.plugins.spotless)
}

// Setup and configure properties that are consistent across all projects, including sub-modules.
allprojects {
    group 'org.mobilitydata.gtfs-validator'

    // Per the axion-release plugin, this computes the project version based
    // on the most recent tag in the repo.
    version scmVersion.version

    repositories {
        mavenCentral()
    }

    tasks.withType(JavaCompile) {
        // All Java projects should target the same compatibility version.
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17

        // Our source files should be encoded in UTF-8, regardless of the platform (e.g. Windows).
        compileJava.options.encoding = "UTF-8"
        compileTestJava.options.encoding = "UTF-8"
    }

    tasks.withType(Javadoc) {
        options.encoding = 'UTF-8'
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    // All projects that include the 'java` plugin will have a Test task by default.
    tasks.withType(Test) {
        // Always run tests, even when nothing changed.
        dependsOn 'cleanTest'

        // Show test results.
        testLogging {
            events "passed", "skipped", "failed"
        }

        // Define a system project for the project version
        systemProperty 'gtfsValidatorVersionForTest', project.version

        // Any project with a test should be added to test report aggregation in the root project.
        rootProject.dependencies.add('testReportAggregation', project)
    }
}

subprojects {
    apply plugin: 'java'
    apply plugin: libs.plugins.spotless.get().pluginId

    task javadocJar(type: Jar) {
        archiveClassifier.set('javadoc')
        from javadoc
    }

    task sourcesJar(type: Jar) {
        archiveClassifier.set('sources')
        from sourceSets.main.allSource
    }

    spotless {
        java {
            googleJavaFormat("1.25.2")
            target("src/**/*.java")
        }
    }

    // These modules require the same publishing configuration, apart from the name of the module
    // Also we want to limit artefact publishing to these modules.
    if (project.name == 'main'
            || project.name == 'core'
            || project.name == 'model'
         ) {
        def fullProjectName = 'gtfs-validator-' + project.name

        afterEvaluate {
            publishing {
                repositories {
                    maven {
                        // Snapshot uses a different repository than release.
                        // The publish in that case will upload to Maven Central snapshot repository.
                        if (version.endsWith('SNAPSHOT')) {
                            url = 'https://central.sonatype.com/repository/maven-snapshots/'
                            credentials {
                                username = System.getenv("MAVEN_CENTRAL_PORTAL_TOKEN_USERNAME")
                                password = System.getenv("MAVEN_CENTRAL_PORTAL_TOKEN_PASSWORD")
                            }
                        } else {
                            // For releases, the publish task does not upload to MavenCentral.
                            // It just creates the artifacts directory hierarchy on the local disk,
                            // The actual zipping and uploading is done in the publishToMavenCentral task.
                            url = "${buildDir}/local-repo"
                        }
                    }
                }

                publications {
                    mavenJava(MavenPublication) {
                        from components.java
                        artifactId = fullProjectName

                        artifact sourcesJar
                        artifact javadocJar

                        // Definition of the pom that will be included with the uploaded artifacts.
                        pom {
                            name = fullProjectName
                            description = 'The ' + project.name + " artifacts from the gtfs validator"
                            url = 'https://github.com/MobilityData/gtfs-validator'
                            licenses {
                                license {
                                    name = 'The Apache License, Version 2.0'
                                    url = 'https://github.com/MobilityData/gtfs-validator/blob/master/LICENSE'
                                }
                            }
                            developers {
                                developer {
                                    id = 'dev'
                                    name = 'Dev group'
                                    email = 'it@mobilitydata.org'
                                }
                            }
                            scm {
                                connection = 'scm:git:git://github.com/MobilityData/gtfs-validator.git'
                                developerConnection = 'scm:git:ssh://github.com/MobilityData/gtfs-validator.git'
                                url = 'https://github.com/MobilityData/gtfs-validator'
                            }
                        }
                    }
                }
            }
            signing {
                useInMemoryPgpKeys(System.getenv('MAVEN_GPG_PRIVATE_KEY'), System.getenv('MAVEN_GPG_PASSPHRASE'))
                sign publishing.publications.mavenJava
            }


            tasks.register('publishToMavenCentral') {
                // We want to do call the publish task only if the version is a release (ie not a snapshot).
                // Without this conditional, with a snapshot it would do the publish first, then throw the Exception below.
                // But since the dependsOn is within the conditional, the dependency is not created for snapshot versions
                // so the publish in that case is never executed.
                if (!version.toString().endsWith('SNAPSHOT')) {
                    dependsOn tasks.publish
                }
                doFirst {
                    if (version.toString().endsWith('SNAPSHOT')) {
                        throw new GradleException("Version \"" + version +
                                "\" is a snapshot. Cannot publish to Maven Central")
                    }
                }

                doLast {
                    exec {
                        workingDir project.projectDir
                        commandLine 'bash', "${project.rootDir}/scripts/publish_to_maven_central.sh", project.name, project.version
                    }
                }
            }

            tasks.register('publishToSnapshotRepository') {
                // We want to call the publish task only if the version is a snapshot.
                // Without this conditional, with a release it would do the publish first, then throw the Exception below.
                // But since the dependsOn is within the conditional, the dependency is not created for release versions
                // so the publish in that case is never executed.
                if (version.toString().endsWith('SNAPSHOT')) {
                    dependsOn tasks.publish
                }
                doFirst {
                    if (!version.toString().endsWith('SNAPSHOT')) {
                        throw new GradleException("Version \"" + version +
                                "\" is a NOT a snapshot. Cannot publish to the snapshot repository")
                    }
                }
            }
        }


    }

    compileJava {
        options.compilerArgs << '-parameters'
    }

    compileTestJava {
        options.compilerArgs << '-parameters'
    }

}

reporting {
    reports {
        // Necessary for unit test result aggregation.
        testAggregateTestReport(AggregateTestReport) {
            testType = TestSuiteType.UNIT_TEST
        }
    }
}

task copyRulesToWebClient (type: Copy) {
    from "./RULES.md"
    into "./web/client/static"
}

build.dependsOn copyRulesToWebClient