ci.yml

name: CI

on:
  pull_request:
  push:
    branches:
      - master
      - "1.13"
    tags: '*'
  workflow_call:
  workflow_dispatch:

# Cancel superseded runs of the same ref, but keep master runs queued.
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}

env:
  # Pinning JULIA_PROJECT at job level lets julia-actions/cache,
  # julia-actions/julia-buildpkg and the inline julia invocations all key
  # off the same Project.toml (OMFrontend.jl/Project.toml lives in a
  # subdirectory of the workspace, so without this the cache action does
  # not find it and the depot cache key falls back to a workflow-wide
  # default).
  JULIA_PROJECT: OMFrontend.jl

jobs:
  test:
    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }}
    runs-on: ${{ matrix.os }}
    timeout-minutes: 90

    strategy:
      fail-fast: false
      matrix:
        # Listing every combination explicitly keeps the matrix predictable.
        include:
          # Coverage is only collected/uploaded on one runner.
          - os: ubuntu-latest
            arch: x64
            version: '1.13'
            coverage: true
          - os: windows-latest
            arch: x64
            version: '1.13'
          - os: macos-latest
            arch: aarch64
            version: '1.13'

    steps:
      - name: Checkout OMFrontend.jl
        uses: actions/checkout@v4
        with:
          path: OMFrontend.jl

      # Project.toml [sources] (and the transitive [sources] inside DoubleEnded
      # / ListUtil) points at sibling working copies in ../<name>.jl. We lay
      # the siblings out alongside the main checkout so Pkg.resolve finds them.
      # The shared action checks the siblings out at the branch that matches
      # this change (the PR branch if the sibling has it, else the PR base
      # branch, e.g. 1.13, else master) from the OpenModelica repositories.
      - name: Checkout sibling OM*.jl packages
        uses: JKRT/OM.jl/.github/actions/checkout-siblings@master
        with:
          packages: Absyn ArrayUtil DAE DoubleEnded ImmutableList ListUtil MetaModelica OMParser OMRuntimeExternalC SCode

      - name: Setup Julia ${{ matrix.version }}-${{ matrix.arch }}
        uses: julia-actions/setup-julia@v2
        with:
          version: ${{ matrix.version }}
          arch: ${{ matrix.arch }}

      - uses: julia-actions/cache@v2
        with:
          # Explicit cache namespace so this workflow does not collide with
          # any future workflow in the repo, and so PR runs share cache with
          # one another rather than with the nightly job.
          cache-name: omfrontend-ci
          cache-registries: 'true'
          include-matrix: 'true'

      - name: Build
        # bash on every runner so we do not have to escape quotes for PowerShell.
        # Compiled modules are enabled (Julia default) so CI exercises the
        # PrecompileTools @compile_workload that ships with OMFrontend; this
        # mirrors what end users hit on first `using OMFrontend`.
        # We Pkg.develop every sibling because Project.toml [sources] only
        # applies to direct deps; DoubleEnded is a transitive dep (via ListUtil)
        # and otherwise falls back to the registry version, which has [compat]
        # incompatible with the local ImmutableList 0.3.0.
        shell: bash
        working-directory: OMFrontend.jl
        run: |
          julia --color=yes --project -e '
            import Pkg
            Pkg.Registry.add("General")
            Pkg.Registry.add(Pkg.RegistrySpec(url = "https://github.com/OpenModelica/OpenModelicaRegistry.git"))
            siblings = [
              "../Absyn.jl",
              "../ArrayUtil.jl",
              "../DAE.jl",
              "../DoubleEnded.jl",
              "../ImmutableList.jl",
              "../ListUtil.jl",
              "../MetaModelica.jl",
              "../OMParser.jl",
              "../OMRuntimeExternalC.jl",
              "../SCode.jl",
            ]
            Pkg.develop([Pkg.PackageSpec(path = p) for p in siblings])
            Pkg.build(; verbose = true)
            Pkg.resolve()
          '

      - name: Test
        # Drive runtests.jl directly (rather than via Pkg.test) so we reuse
        # the precompile cache from the Build step. Pkg.test would create a
        # sandboxed test environment with a different manifest hash and
        # re-precompile the entire dep graph from scratch -- including the
        # OMFrontend @compile_workload, which loads MSL_4_0_0 and is the
        # most expensive part of the build. Test is already in [deps] so
        # no [extras] merging is needed.
        # --code-coverage=user emits .cov files next to user source for the
        # downstream julia-processcoverage step. Only enabled on the coverage
        # runner; the others run tests without the coverage overhead.
        shell: bash
        working-directory: OMFrontend.jl
        run: |
          julia --color=yes ${{ matrix.coverage && '--code-coverage=user' || '' }} --project=. -e '
            include("test/runtests.jl")
          '

      - uses: julia-actions/julia-processcoverage@v1
        if: matrix.coverage
        with:
          directories: OMFrontend.jl/src

      - name: Upload coverage to Codecov
        if: matrix.coverage
        uses: codecov/codecov-action@v4
        with:
          files: lcov.info
          token: ${{ secrets.CODECOV_TOKEN }}
          fail_ci_if_error: false