.github/workflows/ci.yml

env:
  # We aim to always test with the latest stable Rust toolchain, however we pin to a specific
  # version like 1.70. Note that we only specify MAJOR.MINOR and not PATCH so that bugfixes still
  # come automatically. If the version specified here is no longer the latest stable version,
  # then please feel free to submit a PR that adjusts it along with the potential clippy fixes.
  RUST_STABLE_VER: "1.86" # In quotes because otherwise (e.g.) 1.70 would be interpreted as 1.7
  # The purpose of checking with the minimum supported Rust toolchain is to detect its staleness.
  # If the compilation fails, then the version specified here needs to be bumped up to reality.
  # Be sure to also update the rust-version property in the workspace Cargo.toml file,
  # plus all the README.md files of the affected packages.
  RUST_MIN_VER: "1.85"
  # List of packages that will be checked with the minimum supported Rust version.
  # This should be limited to packages that are intended for publishing.
  RUST_MIN_VER_PKGS: "-p vello -p vello_encoding -p vello_shaders -p vello_api -p vello_common -p vello_cpu -p vello_hybrid"
  # List of packages that will be checked for `no_std` builds.
  # This should be limited to packages that are intended for publishing.
  RUST_NO_STD_PKGS: "-p vello_api"
  # List of features that depend on the standard library and will be excluded from no_std checks.
  FEATURES_DEPENDING_ON_STD: "std,default,png"
  # List of packages that can not target Wasm.
  # `vello_tests` uses `nv-flip`, which doesn't support Wasm.
  NO_WASM_PKGS: "--exclude vello_tests"
  # The files stored in LFS the tests need to access, in JSON format
  LFS_FILES: '["vello_tests/snapshots/*.png", "sparse_strips/vello_sparse_tests/snapshots/*.png"]'


# Rationale
#
# We don't run clippy with --all-targets because then even --lib and --bins are compiled with
# dev dependencies enabled, which does not match how they would be compiled by users.
# A dev dependency might enable a feature that we need for a regular dependency,
# and checking with --all-targets would not find our feature requirements lacking.
# This problem still applies to cargo resolver version 2.
# Thus we split all the targets into two steps, one with --lib --bins
# and another with --tests --benches --examples.
# Also, we can't give --lib --bins explicitly because then cargo will error on binary-only packages.
# Luckily the default behavior of cargo with no explicit targets is the same but without the error.
#
# We use cargo-hack for a similar reason. Cargo's --workspace will do feature unification across
# the whole workspace. While cargo-hack will instead check each workspace package separately.
#
# Using cargo-hack also allows us to more easily test the feature matrix of our packages.
# We use --each-feature & --optional-deps which will run a separate check for every feature.
#
# We use cargo-nextest, which has a faster concurrency model for running tests.
# However cargo-nextest does not support running doc tests, so we also have a cargo test --doc step.
# For more information see https://github.com/nextest-rs/nextest/issues/16
#
# The MSRV jobs run only cargo check because different clippy versions can disagree on goals and
# running tests introduces dev dependencies which may require a higher MSRV than the bare package.
#
# For no_std checks we target x86_64-unknown-none, because this target doesn't support std
# and as such will error out if our dependency tree accidentally tries to use std.
# https://doc.rust-lang.org/stable/rustc/platform-support/x86_64-unknown-none.html
#
# We don't save caches in the merge-group cases, because those caches will never be re-used (apart
# from the very rare cases where there are multiple PRs in the merge queue).
# This is because GitHub doesn't share caches between merge queues and the main branch.

name: CI

on:
  pull_request:
  merge_group:
  # We run on push, even though the commit is the same as when we ran in merge_group.
  # This allows the cache to be primed.
  # See https://github.com/orgs/community/discussions/66430
  push:
    branches:
      - main

jobs:
  fmt:
    name: formatting
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install stable toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.RUST_STABLE_VER }}
          components: rustfmt

      - name: cargo fmt
        run: cargo fmt --all --check

      - name: Install Taplo
        uses: uncenter/setup-taplo@09968a8ae38d66ddd3d23802c44bf6122d7aa991 # v1
        with:
          version: "0.9.3"

      - name: Run taplo fmt
        run: taplo fmt --check --diff

      - name: install ripgrep
        run: |
          sudo apt update
          sudo apt install ripgrep

      - name: check copyright headers
        run: bash .github/copyright.sh

  clippy-stable:
    name: cargo clippy
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [windows-latest, macos-latest, ubuntu-latest]
    steps:
      - uses: actions/checkout@v4

      - name: install stable toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.RUST_STABLE_VER }}
          targets: x86_64-unknown-none
          components: clippy

      - name: install cargo-hack
        uses: taiki-e/install-action@v2
        with:
          tool: cargo-hack

      - name: install native dependencies
        if: matrix.os == 'ubuntu-latest'
        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev

      - name: restore cache
        uses: Swatinem/rust-cache@v2
        with:
          save-if: ${{ github.event_name != 'merge_group' }}

      - name: cargo clippy (no_std)
        run: cargo hack clippy ${{ env.RUST_NO_STD_PKGS }} --locked --optional-deps --each-feature --ignore-unknown-features --features libm --exclude-features ${{ env.FEATURES_DEPENDING_ON_STD }} --target x86_64-unknown-none -- -D warnings

      - name: cargo clippy
        run: cargo hack clippy --workspace --locked --optional-deps --each-feature --ignore-unknown-features --features std -- -D warnings

      - name: cargo clippy (auxiliary)
        run: cargo hack clippy --workspace --locked --optional-deps --each-feature --ignore-unknown-features --features std --tests --benches --examples -- -D warnings

  clippy-stable-wasm:
    name: cargo clippy (wasm32)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install stable toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.RUST_STABLE_VER }}
          targets: wasm32-unknown-unknown
          components: clippy

      - name: install cargo-hack
        uses: taiki-e/install-action@v2
        with:
          tool: cargo-hack

      - name: restore cache
        uses: Swatinem/rust-cache@v2
        with:
          save-if: ${{ github.event_name != 'merge_group' }}

      - name: cargo clippy (no_std)
        run: cargo hack clippy ${{ env.RUST_NO_STD_PKGS }} --locked --target wasm32-unknown-unknown --optional-deps --each-feature --ignore-unknown-features --features libm --exclude-features ${{ env.FEATURES_DEPENDING_ON_STD }} -- -D warnings

      - name: cargo clippy
        run: cargo hack clippy --workspace ${{ env.NO_WASM_PKGS }} --locked --target wasm32-unknown-unknown --optional-deps --each-feature --ignore-unknown-features --features std -- -D warnings

      - name: cargo clippy (auxiliary)
        run: cargo hack clippy --workspace ${{ env.NO_WASM_PKGS }} --locked --target wasm32-unknown-unknown --optional-deps --each-feature --ignore-unknown-features --features std --tests --benches --examples -- -D warnings

  prime-lfs-cache:
    name: Prime LFS Cache
    runs-on: ubuntu-latest
    continue-on-error: true
    outputs:
      lfs-hash: ${{ steps.calc-hash.outputs.result }}
    steps:
    - name: Checkout repository
      uses: actions/checkout@v4

    - id: calc-hash
      name: Calculate LFS hash
      # GitHub's expression context doesn't support either a literal newline or an escaped newline. We have to use the JSON parser to get a newline character.
      run: echo "result=${{ hashFiles(join(fromJson(env.LFS_FILES), fromJson('"\n"'))) }}" | tee -a "$GITHUB_OUTPUT"
      
    - name: Cache git lfs
      id: lfs-cache
      uses: actions/cache@v4
      with:
        path: .git/lfs
        # The files targeted with git lfs
        key: vello-lfs-${{ steps.calc-hash.outputs.result }}
        restore-keys: vello-lfs-
        enableCrossOsArchive: true

    - name: Fetch lfs data
      if: ${{ steps.lfs-cache.outputs.cache-hit != 'true' }}
      run: git lfs fetch --include '${{ join(fromJson(env.LFS_FILES), ',') }}'
  
  test-stable:
    name: cargo test
    needs: prime-lfs-cache
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [windows-latest, macos-latest, ubuntu-latest]
        include:
          - os: ubuntu-latest
            gpu: 'yes'
          - os: macos-latest
            gpu: 'yes'
          - os: windows-latest
            # TODO: The windows runners theoretically have CPU fallback for GPUs, but
            # this failed in initial testing
            gpu: 'no'
    steps:
      - uses: actions/checkout@v4
        # We intentionally do not use lfs: true here, instead using the caching method to save LFS bandwidth.

      - name: Restore lfs cache
        id: lfs-cache
        uses: actions/cache/restore@v4
        with:
          path: .git/lfs
          # The files targeted with git lfs
          key: vello-lfs-${{ needs.prime-lfs-cache.outputs.lfs-hash }}
          enableCrossOsArchive: true
  
      - name: Checkout LFS files
        # `git lfs checkout` requires that each individual glob is a separate command line argument.
        # The string `''' '''` is how you write `' '` in GitHub's expression context (i.e. two quotes separated by a space)
        # The quotes are to avoid the shell from evaluating the globs itself.
        run: git lfs checkout '${{ join(fromJson(env.LFS_FILES), ''' ''') }}'
        continue-on-error: true

      - name: install stable toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.RUST_STABLE_VER }}

      - name: install native dependencies
        if: matrix.os == 'ubuntu-latest'
        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev

      # Adapted from https://github.com/bevyengine/bevy/blob/b446374392adc70aceb92621b080d1a6cf7a7392/.github/workflows/validation-jobs.yml#L74-L79
      - name: install xvfb, llvmpipe and lavapipe
        if: matrix.os == 'ubuntu-latest'
        # https://launchpad.net/~kisak/+archive/ubuntu/turtle
        run: |
          sudo apt-get update -y -qq
          sudo add-apt-repository ppa:kisak/turtle -y
          sudo apt-get update
          sudo apt install -y xvfb libegl-mesa0 libgl1-mesa-dri libxcb-xfixes0-dev mesa-vulkan-drivers
      
      - name: install cargo-nextest
        uses: taiki-e/install-action@v2
        with:
          tool: cargo-nextest

      - name: restore cache
        uses: Swatinem/rust-cache@v2
        with:
          save-if: ${{ github.event_name != 'merge_group' }}

      - name: cargo nextest
        # TODO: Maybe use --release; the CPU shaders are extremely slow when unoptimised
        run: cargo nextest run --workspace --locked --all-features --no-fail-fast
        env:
          VELLO_CI_GPU_SUPPORT: ${{ matrix.gpu }}
          # We are experimenting with git lfs, and we don't expect to run out of bandwidth.
          # However, if we do, the tests are designed to be robust against that, if this environment variable is set.
          # If we do run out of bandwidth, uncomment the following line and inform @DJMcNab.
          # VELLO_SKIP_LFS_SNAPSHOTS: all
      
      - name: Upload test results due to failure
        uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: vello-snapshot-tests-${{ matrix.os }}
          path: |
            vello_tests/snapshots
            vello_tests/smoke_snapshots
            vello_tests/comparisons

      - name: cargo test --doc
        run: cargo test --doc --workspace --locked --all-features --no-fail-fast

  test-stable-wasm:
    name: cargo test (wasm32)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install stable toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.RUST_STABLE_VER }}
          targets: wasm32-unknown-unknown

      - name: restore cache
        uses: Swatinem/rust-cache@v2
        with:
          save-if: ${{ github.event_name != 'merge_group' }}

      - name: cargo test compile
        run: cargo test --workspace ${{ env.NO_WASM_PKGS }} --locked --target wasm32-unknown-unknown --all-features --no-run

      - name: install wasm-pack
        uses: taiki-e/install-action@v2
        with:
          tool: wasm-pack

      - name: check vello_hybrid is webgl compatible
        run: wasm-pack test --headless --chrome
        working-directory: sparse_strips/vello_hybrid/examples/webgl


  check-stable-android:
    name: cargo check (aarch64-android)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install stable toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.RUST_STABLE_VER }}
          targets: aarch64-linux-android

      - name: restore cache
        uses: Swatinem/rust-cache@v2
        with:
          save-if: ${{ github.event_name != 'merge_group' }}

      - name: install cargo apk
        run: cargo install cargo-apk

      - name: cargo apk check (android)
        run: cargo apk check -p with_winit --lib
        env:
          # This is a bit of a hack, but cargo apk doesn't seem to allow customising this
          RUSTFLAGS: '-D warnings'

  check-msrv:
    name: cargo check (msrv)
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [windows-latest, macos-latest, ubuntu-latest]
    steps:
      - uses: actions/checkout@v4

      - name: install msrv toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.RUST_MIN_VER }}
          targets: x86_64-unknown-none

      - name: install cargo-hack
        uses: taiki-e/install-action@v2
        with:
          tool: cargo-hack

      - name: install native dependencies
        if: matrix.os == 'ubuntu-latest'
        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev

      - name: restore cache
        uses: Swatinem/rust-cache@v2
        with:
          save-if: ${{ github.event_name != 'merge_group' }}

      - name: cargo check (no_std)
        run: cargo hack check ${{ env.RUST_NO_STD_PKGS }} --locked --optional-deps --each-feature --ignore-unknown-features --features libm --exclude-features ${{ env.FEATURES_DEPENDING_ON_STD }} --target x86_64-unknown-none

      - name: cargo check
        run: cargo hack check ${{ env.RUST_MIN_VER_PKGS }} --locked --optional-deps --each-feature --ignore-unknown-features --features std

  check-msrv-wasm:
    name: cargo check (msrv) (wasm32)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install msrv toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ env.RUST_MIN_VER }}
          targets: wasm32-unknown-unknown

      - name: install cargo-hack
        uses: taiki-e/install-action@v2
        with:
          tool: cargo-hack

      - name: restore cache
        uses: Swatinem/rust-cache@v2
        with:
          save-if: ${{ github.event_name != 'merge_group' }}

      - name: cargo check
        run: cargo hack check ${{ env.RUST_MIN_VER_PKGS }} ${{ env.NO_WASM_PKGS }} --locked --target wasm32-unknown-unknown --optional-deps --each-feature --ignore-unknown-features --features std

  doc:
    name: cargo doc
    # NOTE: We don't have any platform specific docs in this workspace, so we only run on Ubuntu.
    #       If we get per-platform docs (win/macos/linux/wasm32/..) then doc jobs should match that.
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install nightly toolchain
        uses: dtolnay/rust-toolchain@nightly

      - name: restore cache
        uses: Swatinem/rust-cache@v2
        with:
          save-if: ${{ github.event_name != 'merge_group' }}

      # We test documentation using nightly to match docs.rs.
      - name: cargo doc
        run: cargo doc --workspace --locked --all-features --no-deps --document-private-items
        env:
          RUSTDOCFLAGS: '--cfg docsrs -D warnings'

  # If this fails, consider changing your text or adding something to .typos.toml.
  typos:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: check typos
        uses: crate-ci/typos@v1.29.9