build.gradle

import java.time.Duration

import static org.spockframework.gradle.AsciiDocLinkVerifier.verifyAnchorlessCrossDocumentLinks
import static org.spockframework.gradle.AsciiDocLinkVerifier.verifyLinksAndAnchors

plugins {
  id "org.spockframework.base" apply false
  id "base"
  id "org.asciidoctor.jvm.convert"
  id "jacoco"
  id "net.nemerosa.versioning"
  id "io.github.gradle-nexus.publish-plugin"
  id "com.github.ben-manes.versions"
  id "io.spring.nohttp"
}

description = "Spock Framework"

ext {
  baseVersion = "2.4"
  snapshotVersion = true
  milestone = 0
  javaVersions = [8, 11, 17, 21] // ensure that latest version is actually build on GH actions and added to gradle.properties, otherwise no docs get published
  javaVersion = (System.getProperty("javaVersion") ?: 8) as int
  variants = [2.5, 3.0, 4.0]
  variant = System.getProperty("variant") as BigDecimal ?: variants.first()
  develocity.buildScan.tag "groovy-$variant"
  if (variant == 2.5) {
    groovyGroup = "org.codehaus.groovy"
    groovyVersion = libs.versions.groovy2.get()
    minGroovyVersion = "2.5.0"
    maxGroovyVersion = "2.9.99"
    if (javaVersion >= 17) {
      throw new InvalidUserDataException("Groovy $variant is not compatible with Java $javaVersion")
    }
  } else if (variant == 3.0) {
    groovyGroup = "org.codehaus.groovy"
    groovyVersion = libs.versions.groovy3.get()
    minGroovyVersion = "3.0.0"
    maxGroovyVersion = "3.9.99"
  } else if (variant == 4.0) {
    groovyGroup = "org.apache.groovy"
    groovyVersion = libs.versions.groovy4.get()
    minGroovyVersion = "4.0.0"
    maxGroovyVersion = "4.9.99"
  } else {
    throw new InvalidUserDataException("Unknown variant: $variant. Choose one of: $variants")
  }

  groovyDependencies = [
    [group: groovyGroup, name: "groovy", version: groovyVersion]
  ]
  groovyConsoleExtraDependencies = [
    [group: groovyGroup, name: "groovy-console", version: groovyVersion],
    [group: groovyGroup, name: "groovy-test-junit5", version: groovyVersion], // for executing specs
    [group: "org.apache.ivy", name: "ivy", version: "2.5.2"] // for @Grab support
  ]
  maxGroovyVersion = snapshotVersion ? "9.9.99" : maxGroovyVersion
  if (System.getProperty("groovyVersion")) {
    groovyVersion = System.getProperty("groovyVersion")
  }
  fullVersion = baseVersion + ((!snapshotVersion && milestone) ? "-M$milestone" : "") + "-groovy-$variant" + (snapshotVersion ? "-SNAPSHOT" : '')
  variantLessVersion = baseVersion + (snapshotVersion ? "-SNAPSHOT" : (milestone ? "-M$milestone" : ""))
  develocity.buildScan.tag "Java $javaVersion"

  groovylibs = [
    groovy              : groovyDependencies,
    groovyNio           : "$groovyGroup:groovy-nio:$groovyVersion", //for groovy methods on Path
    groovySql           : "$groovyGroup:groovy-sql:$groovyVersion", //for some Spring and Unitils tests
    groovyTest          : "$groovyGroup:groovy-test:$groovyVersion", //for @NotYetImplemented
    groovyJmx           : "$groovyGroup:groovy-jmx:$groovyVersion",  //for triggering jacoco dump via jmx
  ]
}

nohttp {
  source.exclude "**/out/**"
  source.exclude "**/build*/**"
  source.exclude "**/.shelf/**"
}

allprojects {
  ext.displayName = null

  group = "org.spockframework"
  version = fullVersion

  apply from: script("common")

  // ignore mutable data that is irrelevant for compilation output
  normalization {
    runtimeClasspath {
      metaInf {
        ignoreAttribute("Build-Revision")
      }
    }
  }
}

apply from: script("ide")

subprojects {
  apply plugin: "java-library"
  apply plugin: "groovy"
  apply plugin: "jacoco"

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

  tasks.withType(JavaCompile).configureEach {
    if (it.name == 'compileJava') {
      javaCompiler = javaToolchains.compilerFor {
        languageVersion = JavaLanguageVersion.of(8)
      }
    }
    options.encoding = 'UTF-8'
  }
  tasks.withType(GroovyCompile).configureEach {
    options.encoding = 'UTF-8'
  }

  sourceSets.all { ss ->
    for (gv in variants.findAll { variant <= it }) {
      java {
        srcDir "src/${ss.name}-groovy-le-$gv/java"
      }
      groovy {
        srcDir "src/${ss.name}-groovy-le-$gv/groovy"
      }
      resources {
        srcDir "src/${ss.name}-groovy-le-$gv/resources"
      }
    }
    for (jv in javaVersions.findAll { javaVersion <= it }) {
      java {
        srcDir "src/${ss.name}-java-le-$jv/java"
      }
      groovy {
        srcDir "src/${ss.name}-java-le-$jv/groovy"
      }
      resources {
        srcDir "src/${ss.name}-java-le-$jv/resources"
      }
    }
    for (gv in variants.findAll { variant >= it }) {
      java {
        srcDir "src/${ss.name}-groovy-ge-$gv/java"
      }
      groovy {
        srcDir "src/${ss.name}-groovy-ge-$gv/groovy"
      }
      resources {
        srcDir "src/${ss.name}-groovy-ge-$gv/resources"
      }
    }
    for (jv in javaVersions.findAll { javaVersion >= it }) {
      java {
        srcDir "src/${ss.name}-java-ge-$jv/java"
      }
      groovy {
        srcDir "src/${ss.name}-java-ge-$jv/groovy"
      }
      resources {
        srcDir "src/${ss.name}-java-ge-$jv/resources"
      }
    }
  }

  dependencies {
    implementation(project.name == "spock-gradle" ? [] : groovylibs.groovy)
  }

  configureJavadoc(tasks.named("javadoc"))
  configureGroovydoc(tasks.named("groovydoc"))

  tasks.register("sourcesJar", Jar) {
    archiveClassifier = "sources"
    from sourceSets.main.allSource
  }

  tasks.register("javadocJar", Jar) {
    archiveClassifier = "javadoc"
    from javadoc
  }

  tasks.withType(Jar).configureEach {
    /*
     * Ensure the jar can be built in a reproducible manner, This shall prevent build cache misses, when different variants are tested.
     */
    preserveFileTimestamps = false
    reproducibleFileOrder = true
  }

  tasks.withType(Test).configureEach {
    useJUnitPlatform()
    def taskName = name
    reports {
      junitXml {
        outputLocation = file("${outputLocation.get()}/$taskName-$variant")
      }
      html {
        outputLocation = file("${outputLocation.get()}/$taskName-$variant")
      }
    }
    // As a generous general timeout, instead of the 6h of GHA.
    timeout = Duration.ofMinutes(15)
  }

  tasks.register("allDependencyInsight", DependencyInsightReportTask) {}

  jacoco {
    toolVersion = libs.versions.jacoco.get()
  }
}

tasks.register("collectTestXml") {
  group = 'Test reports'
  description = "Collects the test xmls from every subproject into a new directory with subproject as name."
  def reportingProjects = subprojects.findAll()
  dependsOn(reportingProjects.tasks.collectMany { it.withType(Test) })


  doFirst {
    def target = layout.buildDirectory.dir("collected-test-results").get().asFile
    target.mkdirs()
    reportingProjects.each { rp ->
      rp.tasks.withType(Test).each { testTask ->
        def repSrc = testTask.reports.junitXml.destination

        def repTarget = file("$target/$rp.name-$repSrc.name")
        copy {
          from repSrc
          into repTarget
          include '**/*.xml'
        }
      }
    }
  }
}


tasks.register("codeCoverageReport", JacocoReport) {
  group = 'Coverage reports'
  description = "Creates an aggregate coverage for the whole project."
  def reportingProjects = subprojects
  dependsOn(reportingProjects.tasks.collectMany { it.withType(Test) })

  additionalSourceDirs.from(reportingProjects.sourceSets.main.allSource.srcDirs)
  additionalClassDirs.from(reportingProjects.sourceSets.main.output)
  executionData.from(files(reportingProjects.jacocoTestReport.executionData).filter { it.exists() })
  executionData.from(file('spock-specs/build/jacoco/compileTestGroovy.exec'))

  reports {
    html.required = true
    xml.required = true
    xml.outputLocation = layout.buildDirectory.file("reports/jacoco/report.xml") // report must be here for codecov to pick it up
    csv.required = false
  }
}

if (gradle.startParameter.taskNames == ["ghActionsBuild"]) {
  gradle.startParameter.taskNames = ["build", "codeCoverageReport"]
}

if (gradle.startParameter.taskNames == ["ghActionsPublish"] || gradle.startParameter.taskNames == ["ghActionsDocs"]) {
  def originalStartParameterTaskNames = gradle.startParameter.taskNames
  gradle.startParameter.taskNames = []
  boolean isMaster = System.getenv("GITHUB_REF") == "refs/heads/master"
  boolean isTag = System.getenv("GITHUB_REF")?.startsWith('refs/tags/spock-')
  if (!(System.getenv("GITHUB_EVENT_NAME") == "push"
    && (isMaster || isTag)
    && System.getenv("GITHUB_REPOSITORY") == 'spockframework/spock')) {
    throw new IllegalArgumentException("""ghActionsPublish can only be run on push to branch master or tag in repo spockframework/spock
      event: ${System.getenv("GITHUB_EVENT_NAME")}
      ref: ${System.getenv("GITHUB_REF")}
      repo: ${System.getenv("GITHUB_REPOSITORY")}""")
  }

  if (originalStartParameterTaskNames == ["ghActionsPublish"]) {
    if (javaVersion != javaVersions.min()) {
      throw new IllegalArgumentException("ghActionsPublish can only be run on Java ${javaVersions.min()} but was run on $javaVersion")
    }
    /*
      We want to release only snapshots directly from master, final releases will be tagged and then published from that tag.
     */
    if (snapshotVersion) {
      gradle.startParameter.taskNames += ["publishToSonatype"]
    } else if (isTag) {
      gradle.startParameter.taskNames += ["publishToSonatype", "closeSonatypeStagingRepository"]
    } // else {
    // disable tag release for now as this is done with a token, that doesn't trigger other workflows
    // gradle.startParameter.taskNames += ["tagRelease"]
    // }
  }

  if (originalStartParameterTaskNames == ["ghActionsDocs"] && (snapshotVersion || isTag)) {
    if (javaVersion != javaVersions.max()) {
      throw new IllegalArgumentException("ghActionsPublish can only be run on Java ${javaVersions.max()} but was run on $javaVersion")
    }
    if (variant != variants.max()) {
      throw new IllegalArgumentException("ghActionsPublish can only be run with variant ${variants.max()} but was run with $variant")
    }
    gradle.startParameter.taskNames += ["publishJavadoc", "publishDocs"]
  }
}

tasks.register("publishJavadoc", Exec) {
  dependsOn "javadoc"
  commandLine "sh", "-c",
    """
  git config user.email "dev@forum.spockframework.org"
  git config user.name "Spock Framework Robot"
  git fetch origin +gh-pages:gh-pages
  git switch gh-pages
  rm -rf javadoc/$variantLessVersion
  mkdir -p javadoc/$variantLessVersion
  cp -r build/javadoc/$variantLessVersion javadoc/
  git add javadoc
  git commit -qm "Publish javadoc/$variantLessVersion"
  git push "https://\$GITHUB_TOKEN@github.com/spockframework/spock.git" gh-pages 2>&1 | sed "s/\$GITHUB_TOKEN/xxx/g"
  git switch -
"""
}
tasks.register("publishDocs", Exec) {
  dependsOn "asciidoctor"
  commandLine "sh", "-c",
    """
  git config user.email "dev@forum.spockframework.org"
  git config user.name "Spock Framework Robot"
  git fetch origin +gh-pages:gh-pages
  git switch gh-pages
  rm -rf docs/$variantLessVersion
  mkdir -p docs/$variantLessVersion
  cp -r build/docs/asciidoc/* docs/$variantLessVersion
  git add docs
  git commit -qm "Publish docs/$variantLessVersion"
  git push "https://\$GITHUB_TOKEN@github.com/spockframework/spock.git" gh-pages 2>&1 | sed "s/\$GITHUB_TOKEN/xxx/g"
  git switch -
"""
}
tasks.register("tagRelease", Exec) {
  commandLine "sh", "-c",
    """
  git config user.email "dev@forum.spockframework.org"
  git config user.name "Spock Framework Robot"
  git checkout master
  git tag -f spock-$variantLessVersion
  git push "https://\$GITHUB_TOKEN@github.com/spockframework/spock.git" spock-$variantLessVersion 2>&1 | sed "s/\$GITHUB_TOKEN/xxx/g"
"""
}

tasks.register("javadoc", Javadoc) {
  title "Spock Framework API Documentation ($variantLessVersion)"
  destinationDir file("build/javadoc/$variantLessVersion")
  source subprojects.collect { project -> project.tasks.named("javadoc").map { it.source } }
  classpath = files(subprojects.collect { project -> project.tasks.named("javadoc").map { it.classpath } })
}

configureJavadoc(tasks.named("javadoc"), true)

tasks.register("groovydoc", Groovydoc) {
  docTitle "Spock Framework API Documentation ($variantLessVersion)"
  windowTitle "Spock Framework API Documentation ($variantLessVersion)"
  destinationDir file("build/groovydoc/$variantLessVersion")
  source subprojects.collect { project -> project.tasks.named("groovydoc").map { it.source } }
  classpath = files(subprojects.collect { project -> project.tasks.named("groovydoc").map { it.classpath } })
  groovyClasspath = files(projects.spockCore.dependencyProject.tasks.named("groovydoc").map { it.groovyClasspath })

  access = GroovydocAccess.PROTECTED
  processScripts = false
  includeMainForScripts = false
  includeAuthor = false
}

configureGroovydoc(tasks.named("groovydoc"))

configurations {
  asciidoctorExtensions
}

dependencies {
  // local extension from build-logic/asciidoc-extensions
  asciidoctorExtensions 'spockbuild:asciidoc-extensions'
}

asciidoctorj {
  version = libs.versions.asciidoctorj
  fatalWarnings(missingIncludes())
  modules {
    diagram.use()
  }
}

tasks.named("asciidoctor") {
  // work-around for https://github.com/asciidoctor/asciidoctor-gradle-plugin/issues/721
  dependsOn(project.configurations.asciidoctorExtensions)
  configurations 'asciidoctorExtensions'
  sourceDir = "docs"
  baseDirFollowsSourceDir()
  logDocuments = true
  attributes "source-highlighter": "coderay", "linkcss": true, "sectanchors": true, "revnumber": variantLessVersion, "commit-ish": System.getenv("GITHUB_SHA") ?: "master"
  // also treats the included specs as inputs
  inputs.dir file("spock-specs/src/test/groovy/org/spockframework/docs")
  inputs.dir file("spock-specs/src/test/resources/snapshots/org/spockframework/docs")
  inputs.dir file("spock-spring/src/test/groovy/org/spockframework/spring/docs")
  inputs.dir file("spock-spring/src/test/resources/org/spockframework/spring/docs")
  inputs.dir file("spock-spring/boot2-test/src/test/groovy/org/spockframework/boot2")

  doFirst { verifyAnchorlessCrossDocumentLinks(sourceFileTree) }
  doLast { verifyLinksAndAnchors(outputs.files.asFileTree) }
}

nexusPublishing {
  packageGroup = 'org.spockframework'
  repositories {
    sonatype {
      username = System.getenv("SONATYPE_OSS_USER")
      password = System.getenv("SONATYPE_OSS_PASSWORD")
    }
  }
  transitionCheckOptions {
    // closing checks take some time so increase the retries
    // total time is maxRetries(180) * delayBetween(10s) = 30m
    maxRetries.set(180)
  }
}

File script(String name) {
  project.file("gradle/${name}.gradle")
}

def configureJavadoc(TaskProvider javadoc, boolean root = false) {
  javadoc.configure {
    include "spock/**"
    configure(options) {
      options.addStringOption('Xdoclint:none', '-quiet')
      options.noTimestamp()
      options.addStringOption('source', '1.8')
      links "https://docs.groovy-lang.org/docs/groovy-$groovyVersion/html/gapi/"
      links "https://junit.org/junit4/javadoc/latest/"
      links "https://javadoc.io/doc/org.mockito/mockito-core/${libs.versions.mockito5.get()}/"
      // Use offline package list, as the JavaVersion is fixed to 8 for the time being
      // and Hamcrest has certificate issues for their domain.
      linksOffline("https://docs.oracle.com/javase/8/docs/api/", "${root ? '' : '../'}javadoc/java-8")
      linksOffline("https://hamcrest.org/JavaHamcrest/javadoc/2.2/", "${root ? '' : '../'}javadoc/hamcrest-2.2")
    }
  }
}

def configureGroovydoc(TaskProvider groovydoc) {
  groovydoc.configure {
    include "spock/**"
  }
}