main.yml

name: CI

on:
  push:
    branches: ["main"]
  pull_request:
    branches: ["main"]
concurrency:
  group: ${{ github.repository }}-${{ github.ref }}-${{ github.head_ref }}
  cancel-in-progress: true

env:
  CARGO_TERM_COLOR: always

jobs:
  build:
    name: Build (Linux x86-64)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Rust MSRV
        uses: dtolnay/rust-toolchain@1.90.0
      
      - name: Build with locked dependencies
        run: cargo build --locked
      
      - name: Build with no-default-features
        run: cargo build --locked --no-default-features

  format:
    name: Format Check
    runs-on: ubuntu-slim
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt
      
      - name: Check formatting
        run: cargo fmt --all -- --check

  clippy:
    name: Clippy
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Rust MSRV
        uses: dtolnay/rust-toolchain@1.90.0
        with:
          components: clippy
      
      - name: Run Clippy
        run: cargo clippy --all-targets --all-features -- -D warnings

  test:
    name: Test
    needs: [build, format, clippy]
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-24.04
            target: x86_64-unknown-linux-gnu
            rust: stable
          - os: ubuntu-24.04
            target: x86_64-unknown-linux-musl
            rust: stable
          - os: ubuntu-24.04-arm
            target: aarch64-unknown-linux-gnu
            rust: stable
          - os: ubuntu-24.04-arm
            target: aarch64-unknown-linux-musl
            rust: stable
          - os: macos-15
            target: aarch64-apple-darwin
            rust: stable
          - os: windows-2025
            target: x86_64-pc-windows-msvc
            rust: stable
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Rust ${{ matrix.rust }}
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ matrix.rust }}
          targets: ${{ matrix.target }}
      
      - name: Install musl tools (for musl targets)
        if: contains(matrix.target, 'musl')
        run: |
          sudo apt-get update
          sudo apt-get install -y musl-tools
      
      - name: Run tests
        run: cargo test --locked --target ${{ matrix.target }}
      
      - name: Run tests (with default features disabled, Linux x86-64 only)
        if: matrix.target == 'x86_64-unknown-linux-gnu'
        run: cargo test --locked --no-default-features --target ${{ matrix.target }}

  docs:
    name: Documentation
    needs: [build, format, clippy]
    runs-on: ubuntu-slim
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
      
      - name: Build documentation
        run: cargo doc --no-deps --all-features
        env:
          RUSTDOCFLAGS: "-D warnings"
      
      - name: Upload documentation
        uses: actions/upload-artifact@v4
        with:
          name: documentation
          path: target/doc/
          retention-days: 1

  zigbuild:
    name: Zig Build (${{ matrix.target }})
    needs: [build, format, clippy]
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-24.04
            arch: x86-64
            target: x86_64-unknown-linux-gnu
            zigtargetsuffix: .2.28
          - os: ubuntu-24.04-arm
            arch: ARM
            target: aarch64-unknown-linux-gnu
            zigtargetsuffix: .2.28
          - os: ubuntu-24.04
            arch: x86-64
            target: x86_64-unknown-freebsd
            zigtargetsuffix: ""
          - os: ubuntu-24.04-arm
            arch: ARM
            target: aarch64-unknown-freebsd
            zigtargetsuffix: ""
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      
      - name: Install Rust Stable
        uses: dtolnay/rust-toolchain@stable
        if: matrix.target != 'aarch64-unknown-freebsd'
        with:
          targets: ${{ matrix.target }}
          components: rust-src
      
      - name: Install Rust 1.93 (FreeBSD aarch64 special case)
        uses: dtolnay/rust-toolchain@1.93
        if: matrix.target == 'aarch64-unknown-freebsd'
        with:
          components: rust-src
      
      - name: Install Zig
        uses: mlugg/setup-zig@v2
        with:
          version: 0.15.2
      
      - name: Install cargo-zigbuild via cargo-binstall
        uses: taiki-e/install-action@v2
        with:
          tool: cargo-zigbuild@0.21.6
      
      - name: Build with Zig
        if: matrix.target != 'aarch64-unknown-freebsd'
        run: cargo zigbuild --locked --target ${{ matrix.target }}${{ matrix.zigtargetsuffix }}
      
      - name: Build with Zig (FreeBSD aarch64 special case)
        if: matrix.target == 'aarch64-unknown-freebsd'
        run: |
          RUSTC_BOOTSTRAP=1 RUSTFLAGS="-Z unstable-options -C panic=immediate-abort" cargo zigbuild \
          --target aarch64-unknown-freebsd \
          -Z build-std=std,panic_abort
      
      - name: Upload celq binary
        uses: actions/upload-artifact@v4
        with:
          name: celq-${{ matrix.target }}
          path: target/${{ matrix.target }}/debug/celq
          retention-days: 1

  test-debian-oldoldstable:
    name: Test on Debian Oldoldstable for (${{ matrix.target }})
    needs: zigbuild
    strategy:
      matrix:
        include:
          - os: ubuntu-24.04
            target: x86_64-unknown-linux-gnu
          - os: ubuntu-24.04-arm
            target: aarch64-unknown-linux-gnu
    runs-on: ${{ matrix.os }}
    container:
      image: debian:oldoldstable
    steps:
      - uses: actions/checkout@v4
      
      - name: Download celq binary
        uses: actions/download-artifact@v4
        with:
          name: celq-${{ matrix.target }}
          path: ./bin
      
      - name: Make binary executable
        run: chmod +x ./bin/celq
      
      - name: Run smoke test
        run: |
          sh .github/scripts/smoke-test.sh ./bin/celq

  test-freebsd:
    name: Test on FreeBSD (${{ matrix.release }} – ${{ matrix.arch }})
    needs: zigbuild
    runs-on: ubuntu-latest

    strategy:
      matrix:
        include:
          - release: "14.4"
            arch: x86_64
            artifact: celq-x86_64-unknown-freebsd
          - release: "14.4"
            arch: aarch64
            artifact: celq-aarch64-unknown-freebsd

    steps:
      - uses: actions/checkout@v4

      - name: Download celq binary
        uses: actions/download-artifact@v4
        with:
          name: ${{ matrix.artifact }}
          path: ./bin

      - name: Test on FreeBSD
        uses: vmactions/freebsd-vm@v1
        with:
          release: ${{ matrix.release }}
          arch: ${{ matrix.arch }}
          usesh: true
          run: |
            chmod +x ./bin/celq
            sh .github/scripts/smoke-test.sh ./bin/celq


  coverage:
    name: Code Coverage (Ubuntu 24.04 x86-64)
    needs: [build, format, clippy]
    runs-on: ubuntu-24.04

    steps:
      - uses: actions/checkout@v4

      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
        with:
          components: llvm-tools-preview

      - name: Install cargo-llvm-cov via binstall
        uses: taiki-e/install-action@v2
        with:
          tool: cargo-llvm-cov

      - name: Run coverage
        run: |
          cargo llvm-cov \
            --locked \
            --summary-only
  
  openbsd:
    name: OpenBSD (QEMU)
    needs: [build, format, clippy]
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    
    steps:
      - uses: actions/checkout@v4

      - uses: dorny/paths-filter@668c092af3649c4b664c54e4b704aa46782f6f7c # v2
        id: filter
        with:
          filters: |
            rust:
              - '**/*.rs'
              - '**/Cargo.toml'
              - '**/Cargo.lock'
              - '.cirrus.star'
              - '.github/workflows/main.yml'
              - '.cargo/**'
              - 'src/**'
              - 'tests/**'
              - '.github/scripts/smoke-test.sh'
      
      - name: Test on OpenBSD
        if: steps.filter.outputs.rust == 'true'
        uses: vmactions/openbsd-vm@v1
        with:
          release: "7.8"
          usesh: true
          prepare: |
            pkg_add rust
          run: |
            cargo build --locked
            cargo test --locked
    
  netbsd:
    name: NetBSD (QEMU)
    needs: [build, format, clippy]
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    
    steps:
      - uses: actions/checkout@v4

      - uses: dorny/paths-filter@668c092af3649c4b664c54e4b704aa46782f6f7c # v2
        id: filter
        with:
          filters: |
            rust:
              - '**/*.rs'
              - '**/Cargo.toml'
              - '**/Cargo.lock'
              - '.cirrus.star'
              - '.github/workflows/main.yml'
              - '.cargo/**'
              - 'src/**'
              - 'tests/**'
              - '.github/scripts/smoke-test.sh'
      
      - name: Test on NetBSD
        if: steps.filter.outputs.rust == 'true'
        uses: vmactions/netbsd-vm@v1
        with:
          release: "10.1"
          usesh: true
          prepare: |
            /usr/sbin/pkg_add rust
          run: |
            cargo build --locked
            cargo test --locked

  freebsd:
    name: FreeBSD (QEMU)
    needs: [build, format, clippy]
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    
    steps:
      - uses: actions/checkout@v4

      - uses: dorny/paths-filter@668c092af3649c4b664c54e4b704aa46782f6f7c # v2
        id: filter
        with:
          filters: |
            rust:
              - '**/*.rs'
              - '**/Cargo.toml'
              - '**/Cargo.lock'
              - '.cirrus.star'
              - '.github/workflows/main.yml'
              - '.cargo/**'
              - 'src/**'
              - 'tests/**'
              - '.github/scripts/smoke-test.sh'
      
      - name: Test on FreeBSD
        if: steps.filter.outputs.rust == 'true'
        uses: vmactions/freebsd-vm@v1
        with:
          release: "14.4"
          usesh: true
          prepare: |
            pkg install -y rust
          run: |
            cargo build --locked
            cargo test --locked