ci.yml

name: CI

on:
  push:
    branches:
      - master
      - dev
      - boilerplate
      - idiomatic
      - rc1
      - rc2
      - rc3
      - hash-review
  pull_request:

concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: true

env:
  BUILD_TYPE: Release

jobs:
  cell:
    name: CI (${{ matrix.id }})
    strategy:
      fail-fast: false
      matrix:
        include:
          - id: linux-clang
            os: ubuntu-latest
            c_compiler: clang
            cpp_compiler: clang++
          - id: linux-gcc
            os: ubuntu-latest
            c_compiler: gcc
            cpp_compiler: g++
          - id: macos-clang
            os: macos-latest
            c_compiler: clang
            cpp_compiler: clang++
          - id: macos-gcc
            os: macos-latest
            c_compiler: gcc
            cpp_compiler: g++
          - id: windows-cl
            os: windows-latest
            c_compiler: cl
            cpp_compiler: cl
          # `toolchain` carries what is not a compiler: MinGW needs its own
          # generator and PATH, but the compilers it drives are gcc and g++
          - id: windows-mingw
            os: windows-latest
            c_compiler: gcc
            cpp_compiler: g++
            toolchain: mingw
    uses: ./.github/workflows/ci-cell.yml
    with:
      cell-id: ${{ matrix.id }}
      os: ${{ matrix.os }}
      c-compiler: ${{ matrix.c_compiler }}
      cpp-compiler: ${{ matrix.cpp_compiler }}
      build-type: Release
      toolchain: ${{ matrix.toolchain }}
    secrets: inherit

  # Same Windows cells as above, configured with --wide-strings. Performance
  # steps are skipped in the cell when that input is set.
  cell-wide:
    name: CI (${{ matrix.id }})
    strategy:
      fail-fast: false
      matrix:
        include:
          - id: windows-cl-wide
            os: windows-latest
            c_compiler: cl
            cpp_compiler: cl
          - id: windows-mingw-wide
            os: windows-latest
            c_compiler: gcc
            cpp_compiler: g++
            toolchain: mingw
    uses: ./.github/workflows/ci-cell.yml
    with:
      build-type: Release
      c-compiler: ${{ matrix.c_compiler }}
      cell-id: ${{ matrix.id }}
      cpp-compiler: ${{ matrix.cpp_compiler }}
      os: ${{ matrix.os }}
      toolchain: ${{ matrix.toolchain }}
      wide-strings: true
    secrets: inherit

  install-smoke:
    name: Install smoke (${{ matrix.os }}, ${{ matrix.toolchain || matrix.c_compiler }})
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
            c_compiler: gcc
            cpp_compiler: g++
          - os: ubuntu-latest
            c_compiler: clang
            cpp_compiler: clang++
          - os: macos-latest
            c_compiler: clang
            cpp_compiler: clang++
          - os: windows-latest
            c_compiler: cl
            cpp_compiler: cl
          - os: windows-latest
            c_compiler: gcc
            cpp_compiler: g++
            toolchain: mingw

    steps:
      - uses: actions/checkout@v4

      - name: Install Clang (Ubuntu)
        if: runner.os == 'Linux' && matrix.c_compiler == 'clang'
        run: sudo apt-get update && sudo apt-get install -y clang

      - name: Setup MSYS2 MinGW
        if: runner.os == 'Windows' && matrix.toolchain == 'mingw'
        uses: msys2/setup-msys2@v2
        with:
          msystem: MINGW64
          update: true
          install: >-
            mingw-w64-x86_64-toolchain
            mingw-w64-x86_64-cmake
            mingw-w64-x86_64-make

      - name: Helper scripts prepare-clean-build-remove-reprepare-build
        shell: bash
        run: |
          set -euo pipefail
          # Exercise prepare/clean/build/remove helpers on a dedicated tree
          # (does not replace the install-smoke configure/build below).
          export SIS_CMAKE_BUILD_DIR="${{ github.workspace }}/_build-helper-smoke"
          PREPARE_ARGS=(-E -T)
          if [ "${{ matrix.toolchain }}" = "mingw" ]; then
            export PATH="/mingw64/bin:$PATH"
            PREPARE_ARGS+=(--mingw)
          elif [ "${{ matrix.c_compiler }}" != "cl" ]; then
            export CC="${{ matrix.c_compiler }}"
            export CXX="${{ matrix.cpp_compiler }}"
          fi
          ./prepare_cmake.sh "${PREPARE_ARGS[@]}"
          ./clean_cmake.sh
          ./build_cmake.sh
          ./clean_cmake.sh
          ./build_cmake.sh
          ./remove_cmake_artefacts.sh
          ./prepare_cmake.sh "${PREPARE_ARGS[@]}"
          ./build_cmake.sh

      - name: Configure
        shell: bash
        run: |
          set -euo pipefail
          if [ "${{ matrix.c_compiler }}" = "cl" ]; then
            cmake -B build -S . \
              -DCMAKE_DISABLE_FIND_PACKAGE_MFC=TRUE \
              -DBUILD_EXAMPLES=OFF \
              -DBUILD_TESTING=OFF
          elif [ "${{ matrix.toolchain }}" = "mingw" ]; then
            export PATH="/mingw64/bin:$PATH"
            cmake -B build -G "MinGW Makefiles" \
              -DCMAKE_BUILD_TYPE="${{ env.BUILD_TYPE }}" \
              -DCMAKE_C_COMPILER=gcc \
              -DCMAKE_CXX_COMPILER=g++ \
              -DBUILD_EXAMPLES=OFF \
              -DBUILD_TESTING=OFF
          else
            cmake -B build -S . \
              -DCMAKE_BUILD_TYPE="${{ env.BUILD_TYPE }}" \
              -DCMAKE_C_COMPILER="${{ matrix.c_compiler }}" \
              -DCMAKE_CXX_COMPILER="${{ matrix.cpp_compiler }}" \
              -DBUILD_EXAMPLES=OFF \
              -DBUILD_TESTING=OFF
          fi

      - name: Build
        shell: bash
        run: |
          set -euo pipefail
          if [ "${{ matrix.c_compiler }}" = "cl" ]; then
            cmake --build build --config "${{ env.BUILD_TYPE }}" --parallel
          elif [ "${{ matrix.toolchain }}" = "mingw" ]; then
            export PATH="/mingw64/bin:$PATH"
            cmake --build build --parallel 2
          else
            cmake --build build --parallel
          fi

      - name: Install
        shell: bash
        run: |
          set -euo pipefail
          PREFIX="${RUNNER_TEMP}/install-prefix"
          echo "INSTALL_PREFIX=$PREFIX" >> "$GITHUB_ENV"
          if [ "${{ matrix.c_compiler }}" = "cl" ]; then
            cmake --install build --config "${{ env.BUILD_TYPE }}" --prefix "$PREFIX"
          else
            cmake --install build --prefix "$PREFIX"
          fi

      - name: Verify install tree
        shell: bash
        run: |
          set -euo pipefail
          test -f "${INSTALL_PREFIX}/include/cstring/cstring.h"
          test -f "${INSTALL_PREFIX}/lib/cmake/cstring/cstring-config.cmake"

      - name: Configure and run install smoke consumer
        shell: bash
        run: |
          set -euo pipefail
          CONSUMER="${RUNNER_TEMP}/consumer"
          mkdir -p "$CONSUMER"
          cat > "$CONSUMER/CMakeLists.txt" <<'EOF'
          cmake_minimum_required(VERSION 3.13)
          project(cstring_install_smoke C)
          find_package(cstring REQUIRED)
          add_executable(consumer consumer.c)
          target_link_libraries(consumer PRIVATE cstring::core)
          EOF
          cat > "$CONSUMER/consumer.c" <<'EOF'
          #include <cstring/cstring.h>
          int main(void) { return 0; }
          EOF
          if [ "${{ matrix.c_compiler }}" = "cl" ]; then
            cmake -S "$CONSUMER" -B consumer-build \
              -DCMAKE_PREFIX_PATH="${INSTALL_PREFIX};${{ env.SIS_DEPS }}"
            cmake --build consumer-build --config "${{ env.BUILD_TYPE }}" --parallel
            consumer-build/${{ env.BUILD_TYPE }}/consumer.exe
          elif [ "${{ matrix.toolchain }}" = "mingw" ]; then
            export PATH="/mingw64/bin:$PATH"
            cmake -S "$CONSUMER" -B consumer-build -G "MinGW Makefiles" \
              -DCMAKE_BUILD_TYPE="${{ env.BUILD_TYPE }}" \
              -DCMAKE_PREFIX_PATH="${INSTALL_PREFIX}"
            cmake --build consumer-build --parallel 2
            consumer-build/consumer.exe
          else
            cmake -S "$CONSUMER" -B consumer-build \
              -DCMAKE_BUILD_TYPE="${{ env.BUILD_TYPE }}" \
              -DCMAKE_C_COMPILER="${{ matrix.c_compiler }}" \
              -DCMAKE_CXX_COMPILER="${{ matrix.cpp_compiler }}" \
              -DCMAKE_PREFIX_PATH="${INSTALL_PREFIX}"
            cmake --build consumer-build --parallel
            consumer-build/consumer
          fi

  no-cpp:
    name: Build with --no-cpp
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Install test dependencies (STLSoft + shwild + xTests)
        uses: ./.github/actions/install-sis-deps
        with:
          build-type: ${{ env.BUILD_TYPE }}
          c-compiler: gcc
          cpp-compiler: g++
          dependencies: STLSoft shwild xTests

      - name: Configure via prepare_cmake.sh --no-cpp
        shell: bash
        run: |
          set -euo pipefail
          # Prefer CMAKE_PREFIX_PATH (find_package) over prepare_cmake -s /
          # -DSTLSOFT: xTests::core links STLSoft::STLSoft, which only
          # exists when the STLSoft CMake package is imported.
          export CMAKE_PREFIX_PATH="${{ env.SIS_DEPS }}"
          ./prepare_cmake.sh --no-cpp

      - name: Build via build_cmake.sh
        shell: bash
        run: |
          set -euo pipefail
          export CMAKE_PREFIX_PATH="${{ env.SIS_DEPS }}"
          ./build_cmake.sh

      - name: Run automated tests
        shell: bash
        run: |
          set -euo pipefail
          SIS_CMAKE_BUILD_DIR="${{ github.workspace }}/_build" ./run_all_automated_tests.sh -M

  wide-strings:
    name: Build with --wide-strings
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Install test dependencies (STLSoft + shwild + xTests)
        uses: ./.github/actions/install-sis-deps
        with:
          build-type: ${{ env.BUILD_TYPE }}
          c-compiler: gcc
          cpp-compiler: g++
          dependencies: STLSoft shwild xTests

      - name: Configure via prepare_cmake.sh --wide-strings
        shell: bash
        run: |
          set -euo pipefail
          # Same prefix rule as the --no-cpp job: xTests::core links
          # STLSoft::STLSoft, which exists only when that package is
          # imported. --wide-strings defines CSTRING_USE_WIDE_STRINGS.
          export CMAKE_PREFIX_PATH="${{ env.SIS_DEPS }}"
          ./prepare_cmake.sh --wide-strings

      - name: Build via build_cmake.sh
        shell: bash
        run: |
          set -euo pipefail
          export CMAKE_PREFIX_PATH="${{ env.SIS_DEPS }}"
          ./build_cmake.sh

      - name: Run automated tests
        shell: bash
        run: |
          set -euo pipefail
          SIS_CMAKE_BUILD_DIR="${{ github.workspace }}/_build" ./run_all_automated_tests.sh -M

      - name: Run examples
        shell: bash
        run: |
          set -euo pipefail
          SIS_EXAMPLE_SMOKE=1 \
            SIS_CMAKE_BUILD_DIR="${{ github.workspace }}/_build" \
            ./run_all_examples.sh -M