vim/.github/workflows/ci-linux.yml

name: CI for Linux

on:
  workflow_call:

# Cancels all previous workflow runs for pull requests that have not completed.
concurrency:
  # The concurrency group contains the workflow name and the branch name for
  # pull requests or the commit hash for any other events.
  group: ${{ github.workflow }}-linux-${{ github.event_name == 'pull_request' && github.head_ref || github.sha }}
  cancel-in-progress: true

permissions:
  contents: read # to fetch code (actions/checkout)

jobs:
  linux:
    runs-on: ${{ matrix.architecture == 'arm64' && 'ubuntu-26.04-arm' || 'ubuntu-26.04' }}

    env:
      CC: ${{ matrix.compiler }}
      GCC_VER: 16
      CLANG_VER: 22
      TEST: test
      SRCDIR: ./src
      LEAK_CFLAGS: -DEXITFREE
      LOG_DIR: ${{ github.workspace }}/logs
      TERM: xterm
      DISPLAY: ":99"
      WAYLAND_DISPLAY: "/tmp/weston_sock"
      GTK_A11Y: "none"
      GDK_DEBUG: "no-portals"
      DEBIAN_FRONTEND: noninteractive

    strategy:
      fail-fast: false
      matrix:
        features: [tiny, normal, huge]
        compiler: [clang, gcc]
        extra: [[]]
        # Only use non-native architecture when features != huge.
        # features=huge tries to install python3-dev, which fails to install
        # for the non-native architecture.
        architecture: [native]
        include:
          - features: tiny
            compiler: clang
            extra: [nogui]
          - features: tiny
            compiler: gcc
            extra: [nogui, syn_test_execs_naming]
          - features: tiny
            compiler: gcc
            extra: [nogui]
            architecture: arm64
          - features: normal
            shadow: ./src/shadow
            compiler: gcc
            architecture: i386
          - features: huge
            coverage: true
          - features: huge
            compiler: clang
            interface: dynamic
            python3: stable-abi
          - features: huge
            compiler: gcc
            coverage: true
            interface: dynamic
            extra: [uchar, testgui]
          - features: huge
            compiler: gcc
            interface: dynamic
            extra: [uchar, testgui, use_gtk4]
          - features: huge
            compiler: gcc
            coverage: true
            extra: [unittests]
          - features: huge
            compiler: gcc
            coverage: true
            extra: [unittests]
            architecture: arm64
          - features: normal
            compiler: gcc
            extra: [vimtags, proto, preproc_indent, encoding, codestyle]
          - features: huge
            compiler: gcc
            extra: [no_x11_wl]

    steps:
      - name: Checkout repository from GitHub
        uses: actions/checkout@v7.0.1

      - name: Build
        timeout-minutes: 15
        uses: ./.github/actions/build_vim_on_linux
        with:
          features: ${{ matrix.features }}
          compiler: ${{ matrix.compiler }}
          architecture: ${{ matrix.architecture }}
          extra: ${{ toJSON(matrix.extra) }}
          shadow: ${{ matrix.shadow }}
          interface: ${{ matrix.interface }}
          lua_ver: ${{ matrix.lua_ver }}
          python3: ${{ matrix.python3 }}
          coverage: ${{ matrix.coverage }}

      - name: Test
        timeout-minutes: 20
        # The GTK4 GUI is not stable enough yet to block the other jobs: it
        # is the only job that runs a Wayland compositor, which makes
        # 'clipboard' behave differently.
        continue-on-error: ${{ contains(matrix.extra, 'use_gtk4') }}
        run: make ${SHADOWOPT} ${TEST}

      # Enable to debug failing tests live and ssh into the CI runners
      # - name: Setup tmate session
      #   if: ${{ failure() }}
      #   uses: mxschmitt/action-tmate@v3
      #   with:
      #     limit-access-to-actor: true

      - name: Upload failed test artifacts
        if: ${{ !cancelled() }}
        uses: ./.github/actions/test_artifacts

      - name: Vim tags
        if: contains(matrix.extra, 'vimtags')
        run: |
          # This will exit with an error code if the generated vim tags differs from source.
          (
            cd runtime/doc
            git diff --exit-code -- tags
            make html; rm *.html tags.ref;
            test -f errors.log && exit 3;
            true
          )

      - name: Generate Proto files
        if: contains(matrix.extra, 'proto')
        run: |
          # This will exit with an error code if the generated proto files differ from source
          (
            git diff --exit-code -- src/proto/
            true
          )

      - name: Check Source Code style
        if: contains(matrix.extra, 'codestyle')
        run: |
          make -C src/testdir codestyle

      - name: Check preprocessor indent
        if: contains(matrix.extra, 'preproc_indent')
        run: |
          # This will exit with an error code if the files differ from source
          (
            "${SRCDIR}"/vim -u NONE --not-a-term -esNX +"cd runtime/tools" -S preproc_indent.vim
            git diff --exit-code -- src/*.[ch] src/xxd/xxd.c
            true
          )

      - name: Check encoding of utf-8 runtime files
        if: contains(matrix.extra, 'encoding')
        run: |
          # This will exit with an error code if utf-8 runtime files are not in utf-8 encoding
          (
            find . -type f -name "*utf-8*.vim" -exec sh -c \
              'iconv -f utf-8 -t utf-8 "$1" >/dev/null 2>&1 || echo "non utf-8 encoding detected in $1"' \
              find-sh {} \; |grep  "non utf-8 encoding" && exit 3
            true
          )

      - name: Generate gcov files
        if: matrix.coverage
        run: |
          cd "${SRCDIR}"
          find . -type f -name '*.gcno' -exec gcov -pb {} + || true

      - name: Codecov
        timeout-minutes: 20
        if: matrix.coverage
        uses: codecov/codecov-action@v7
        with:
          flags: linux,${{ matrix.features }}-${{ matrix.compiler }}-${{ join(matrix.extra, '-') }}
          token: ${{ secrets.CODECOV_TOKEN }}