ci.yml

name: Test a Scala project

on:
  workflow_call:
    inputs:
      scala_versions:
        description: 'JSON array of Scala versions to build against'
        type: string
        default: '["2.13.18", "3.3.8"]'
      java_version:
        description: 'JDK version'
        type: string
        default: '17'
      java_distribution:
        description: 'JDK distribution'
        type: string
        default: 'temurin'
      test_task:
        description: >-
          sbt task that runs the tests. Defaults to `testFull` on sbt 2 and `test` on sbt 1,
          detected from project/build.properties.
        type: string
        default: ''
      clean_task:
        description: >-
          sbt task that cleans the working directory. Defaults to `cleanFull` on sbt 2 and 
          `clean` on sbt 1, detected from project/build.properties.
        type: string
        default: ''
      sonar:
        description: >-
          Run a SonarQube Cloud scan. Requires a SONAR_TOKEN secret and an existing project on
          SonarQube Cloud with Automatic Analysis turned off, otherwise the two conflict.
        type: boolean
        default: false
      sonar_project_key:
        description: 'SonarQube project key. Defaults to <owner>_<repo>.'
        type: string
        default: ''
      sonar_args:
        description: 'Extra -D arguments for the Sonar scanner'
        type: string
        default: ''
    secrets:
      SONAR_TOKEN:
        description: >-
          Only needed with `sonar: true`. Declared so callers do not have to use `secrets: inherit`,
          which SonarQube Cloud's own quality gate flags.
        required: false

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  sbt-tasks:
    runs-on: ubuntu-latest

    steps:
      - name: checkout
        uses: actions/checkout@v7
        with:
          persist-credentials: false

      - name: resolve test task
        id: test-task
        env:
          TEST_TASK: ${{ inputs.test_task }}
        run: |
          if [[ -n "$TEST_TASK" ]]; then
            echo "test=$TEST_TASK" >> "$GITHUB_OUTPUT"
          elif grep -qE '^sbt\.version\s*=\s*2\.' project/build.properties; then
            # sbt 2 redefined `test` to run only tests that failed or never ran
            echo "test=testFull" >> "$GITHUB_OUTPUT"
          else
            echo "test=test" >> "$GITHUB_OUTPUT"
          fi

      - name: resolve clean task
        id: clean-task
        env:
          CLEAN_TASK: ${{ inputs.clean_task }}
        run: |
          if [[ -n "$CLEAN_TASK" ]]; then
            echo "clean=$CLEAN_TASK" >> "$GITHUB_OUTPUT"
          elif grep -qE '^sbt\.version\s*=\s*2\.' project/build.properties; then
            # in sbt 2 the `clean` doesn't remove all generated classes
            echo "clean=cleanFull" >> "$GITHUB_OUTPUT"
          else
            echo "clean=clean" >> "$GITHUB_OUTPUT"
          fi

    outputs:
      test: ${{ steps.test-task.outputs.test }}
      clean: ${{ steps.clean-task.outputs.clean }}

  test-coverage:
    runs-on: ubuntu-latest
    needs: [sbt-tasks]
    strategy:
      fail-fast: false
      matrix:
        scala: ${{ fromJSON(inputs.scala_versions) }}

    steps:
      - name: checkout
        uses: actions/checkout@v7
        with:
          persist-credentials: false
          # checkout whole history with all tags - required by `sonar` for blame
          fetch-depth: 0

      - name: restore cache
        uses: coursier/cache-action@v8

      - name: setup Java ${{ inputs.java_version }}
        uses: actions/setup-java@v5
        with:
          java-version: ${{ inputs.java_version }}
          distribution: ${{ inputs.java_distribution }}
          cache: 'sbt'

      - name: setup SBT
        uses: sbt/setup-sbt@v1
        with:
          # sbt 2's disk cache is restored across runs. Disable disk cache to force full coverage run
          disk-cache: false

      # The coverage build runs before any other compile: scoverage's instrumentation is not part of
      # sbt's compile cache key, so a plain compile done first would be reused here and the coverage
      # report would come out empty.
      - name: build ${{ matrix.scala }}
        run: |
          sbt "++${{ matrix.scala }}; ${{ needs.sbt-tasks.outputs.clean }}; coverage; ${{ needs.sbt-tasks.outputs.test }}; coverageAggregate"

      - name: locate coverage report
        id: coverage
        if: success()
        run: echo "file=$(find . -path '*/coverage-report/cobertura.xml' | head -1)" >> "$GITHUB_OUTPUT"

      - name: fail if coverage report is empty
        if: success()
        env:
          REPORT: ${{ steps.coverage.outputs.file }}
        run: |
          if [[ -z "$REPORT" || ! -f "$REPORT" ]]; then
            echo "::error::no cobertura report was produced"
            exit 1
          fi
          # Only the root <coverage> element's totals matter; individual classes may legitimately
          # have no lines.
          valid=$(grep -m1 -oE 'lines-valid="[0-9]+"' "$REPORT" | grep -oE '[0-9]+')
          if [[ "${valid:-0}" -eq 0 ]]; then
            echo "::error::coverage report is empty - instrumentation did not run"
            exit 1
          fi

      - name: upload coverage
        if: success()
        uses: coverallsapp/github-action@v2
        with:
          file: ${{ steps.coverage.outputs.file }}
          format: cobertura
          flag-name: Scala ${{ matrix.scala }}
          parallel: true

      # Scanned once, on the first Scala version only: SonarQube tracks one analysis per branch, so
      # running it per matrix leg would have the legs overwrite each other.
      - name: sonar settings
        id: sonar
        if: inputs.sonar && matrix.scala == fromJSON(inputs.scala_versions)[0]
        env:
          KEY: ${{ inputs.sonar_project_key }}
        run: |
          if [[ -z "$KEY" ]]; then
            KEY="${GITHUB_REPOSITORY/\//_}"
          fi
          echo "key=$KEY" >> "$GITHUB_OUTPUT"
          # scoverage writes one report per module; Sonar takes a comma separated list
          reports=$(find . -path '*/scoverage-report/scoverage.xml' | paste -sd, -)
          echo "reports=$reports" >> "$GITHUB_OUTPUT"

      - name: sonar scan
        if: inputs.sonar && matrix.scala == fromJSON(inputs.scala_versions)[0]
        uses: SonarSource/sonarqube-scan-action@v8
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
        with:
          args: >
            -Dsonar.organization=${{ github.repository_owner }}
            -Dsonar.projectKey=${{ steps.sonar.outputs.key }}
            -Dsonar.scala.coverage.reportPaths=${{ steps.sonar.outputs.reports }}
            ${{ inputs.sonar_args }}

  # Closes the parallel Coveralls build once every matrix leg has uploaded its part. Without
  # `parallel: true` the first upload closes the build and the other legs get rejected with
  # "Can't add a job to a build that is already closed".
  coverage-finished:
    runs-on: ubuntu-latest
    needs: [test-coverage]
    if: ${{ !cancelled() }}

    steps:
      - name: finish Coveralls build
        uses: coverallsapp/github-action@v2
        with:
          parallel-finished: true

  binary-compatibility:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        scala: ${{ fromJSON(inputs.scala_versions) }}

    steps:
      - name: checkout
        uses: actions/checkout@v7
        with:
          persist-credentials: false
          # checkout whole history with all tags - required by `versionPolicyCheck` for version comparison
          fetch-depth: 0

      - name: restore cache
        uses: coursier/cache-action@v8

      - name: setup Java ${{ inputs.java_version }}
        uses: actions/setup-java@v5
        with:
          java-version: ${{ inputs.java_version }}
          distribution: ${{ inputs.java_distribution }}
          cache: 'sbt'

      - name: setup SBT
        uses: sbt/setup-sbt@v1

      - name: binary compatibility ${{ matrix.scala }}
        run: sbt "++${{ matrix.scala }}; versionPolicyCheck"

  formatting:
    runs-on: ubuntu-latest
    steps:
      - name: checkout
        uses: actions/checkout@v7
        with:
          persist-credentials: false

      - name: restore cache
        uses: coursier/cache-action@v8

      - name: setup Java ${{ inputs.java_version }}
        uses: actions/setup-java@v5
        with:
          java-version: ${{ inputs.java_version }}
          distribution: ${{ inputs.java_distribution }}
          cache: 'sbt'

      - name: setup SBT
        uses: sbt/setup-sbt@v1

      - name: formatting
        run: sbt "scalafmtCheckRepo"

  scaladoc:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        scala: ${{ fromJSON(inputs.scala_versions) }}

    steps:
      - name: checkout
        uses: actions/checkout@v7
        with:
          persist-credentials: false

      - name: restore cache
        uses: coursier/cache-action@v8

      - name: setup Java ${{ inputs.java_version }}
        uses: actions/setup-java@v5
        with:
          java-version: ${{ inputs.java_version }}
          distribution: ${{ inputs.java_distribution }}
          cache: 'sbt'

      - name: setup SBT
        uses: sbt/setup-sbt@v1
        with:
          # sbt 2's disk cache is restored across runs. Disable disk cache to force full Scaladoc recompilation
          disk-cache: false

      - name: scaladoc ${{ matrix.scala }}
        run: sbt "++${{ matrix.scala }}; Compile/doc"