cpal.yml

name: cpal

on:
  push:
    branches: [master]
    paths-ignore:
      - "**.md"
      - "docs/**"
      - "LICENSE*"
      - ".gitignore"
      - "Dockerfile*"
      - "Cross.toml"
  pull_request:
    branches: [master]
    paths-ignore:
      - "**.md"
      - "docs/**"
      - "LICENSE*"
      - ".gitignore"
      - "Dockerfile*"
      - "Cross.toml"
  release:
    types: [published]

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

  clippy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5

      - name: Cache Linux audio packages
        uses: awalsh128/cache-apt-pkgs-action@latest
        with:
          packages: libasound2-dev libjack-jackd2-dev libjack-jackd2-0 libdbus-1-dev

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy
          targets: armv7-linux-androideabi

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2

      - name: Run clippy
        run: cargo clippy --all --all-features
      - name: Run clippy for Android target
        run: cargo clippy --all --features asio --target armv7-linux-androideabi

  cargo-publish:
    if: github.event_name == 'release'
    needs: [test-native, test-cross, test-wasm, test-android, test-ios, test-windows-versions]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5

      - name: Cache Linux audio packages
        uses: awalsh128/cache-apt-pkgs-action@latest
        with:
          packages: libasound2-dev libjack-jackd2-dev libjack-jackd2-0 libdbus-1-dev

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable

      # Verify the release tag matches Cargo.toml version
      - name: Verify release version
        run: |
          CARGO_VERSION=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0].version')
          RELEASE_VERSION=${GITHUB_REF#refs/tags/v}
          echo "Cargo.toml version: $CARGO_VERSION"
          echo "Release tag version: $RELEASE_VERSION"
          if [ "$CARGO_VERSION" != "$RELEASE_VERSION" ]; then
            echo "Version mismatch! Cargo.toml has $CARGO_VERSION but release tag is v$RELEASE_VERSION"
            exit 1
          fi

      - name: Publish to crates.io
        run: cargo publish --token ${{ secrets.CRATESIO_TOKEN }}

  # Native platform testing
  test-native:
    strategy:
      fail-fast: false
      matrix:
        include:
          # Linux x86_64
          - os: ubuntu-latest
            name: linux-x64

          # Linux ARM64 native
          - os: ubuntu-24.04-arm
            name: linux-arm64

          # Windows x86_64
          - os: windows-latest
            name: windows-x64
            target: x86_64-pc-windows-msvc
            deps: |
              curl -L -o asio.zip https://www.steinberg.net/asiosdk
              7z x -oasio asio.zip
              move asio\*\* asio\
              choco install asio4all
              choco install llvm
            asio-env: true

          # Windows i686
          - os: windows-latest
            name: windows-x86
            target: i686-pc-windows-msvc
            deps: |
              curl -L -o asio.zip https://www.steinberg.net/asiosdk
              7z x -oasio asio.zip
              move asio\*\* asio\
              choco install asio4all
              choco install llvm
            asio-env: true

          # macOS (ARM64 M1/M2)
          - os: macOS-latest
            name: macos-arm64
            deps: brew install llvm
            build-beep: true

    runs-on: ${{ matrix.os }}
    name: test-${{ matrix.name }}
    steps:
      - uses: actions/checkout@v5

      - name: Cache Linux audio packages
        if: runner.os == 'Linux'
        uses: awalsh128/cache-apt-pkgs-action@latest
        with:
          packages: libasound2-dev libjack-jackd2-dev libjack-jackd2-0 libdbus-1-dev

      - name: Install non-Linux dependencies
        if: runner.os != 'Linux'
        run: ${{ matrix.deps }}

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          target: ${{ matrix.target }}

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2

      - name: Build beep example (macOS only)
        if: matrix.build-beep
        run: cargo build --example beep

      - name: Run tests without features
        run: cargo test --all --no-default-features --verbose

      - name: Run tests with all features
        shell: bash
        run: |
          if [[ "${{ matrix.asio-env }}" == "true" ]]; then
            export CPAL_ASIO_DIR="$GITHUB_WORKSPACE/asio"
          fi
          cargo test --all --all-features --verbose

  # Cross-compilation for architectures without native runners
  test-cross:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        target: [armv7-unknown-linux-gnueabihf]

    steps:
      - uses: actions/checkout@v5

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          target: ${{ matrix.target }}

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2
        with:
          key: cross-${{ matrix.target }}

      - name: Install cross
        uses: taiki-e/install-action@v2
        with:
          tool: cross

      - name: Test without features
        run: cross test --target ${{ matrix.target }} --workspace --no-default-features --verbose

      - name: Test all features
        run: cross test --target ${{ matrix.target }} --workspace --all-features --verbose

  # WebAssembly builds
  test-wasm:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        include:
          - target: wasm32-unknown-emscripten
            setup-emscripten: true
            args: --release
          - target: wasm32-unknown-unknown
            setup-emscripten: false
            args: --features=wasm-bindgen
            build-wasm-beep: true
          - target: wasm32-wasip1
            setup-emscripten: false
            args: ""

    steps:
      - uses: actions/checkout@v5

      - name: Setup Emscripten toolchain
        if: matrix.setup-emscripten
        uses: mymindstorm/setup-emsdk@v14

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          target: ${{ matrix.target }}

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2
        with:
          key: wasm-${{ matrix.target }}

      - name: Build beep example
        run: cargo build --example beep --target ${{ matrix.target }} ${{ matrix.args }}

      - name: Build wasm-beep example
        if: matrix.build-wasm-beep
        working-directory: ./examples/wasm-beep
        run: cargo build --target ${{ matrix.target }}

  # Android cross-compilation
  test-android:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5

      - name: Install Rust toolchain (Android targets)
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: armv7-linux-androideabi,aarch64-linux-android,i686-linux-android,x86_64-linux-android

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2
        with:
          key: android

      - name: Check Android examples
        run: |
          cargo check --example beep --target armv7-linux-androideabi --verbose
          cargo check --example enumerate --target armv7-linux-androideabi --verbose
          cargo check --example feedback --target armv7-linux-androideabi --verbose
          cargo check --example record_wav --target armv7-linux-androideabi --verbose

      - name: Check Android project
        working-directory: examples/android
        run: cargo check --target armv7-linux-androideabi --verbose

      - name: Setup Android SDK
        uses: android-actions/setup-android@v3
        with:
          packages: platforms;android-30 build-tools;30.0.3

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

      - name: Build APK
        working-directory: examples/android
        run: cargo apk build

  # iOS cross-compilation
  test-ios:
    runs-on: macOS-latest
    steps:
      - uses: actions/checkout@v5

      - name: Install dependencies
        run: brew install llvm

      - name: Install Rust toolchain (iOS targets)
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: aarch64-apple-ios,x86_64-apple-ios

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2
        with:
          key: ios

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

      - name: Build iOS example
        run: cd examples/ios-feedback && xcodebuild -scheme cpal-ios-example -configuration Debug -derivedDataPath build -sdk iphonesimulator

  # Windows crate compatibility testing
  test-windows-versions:
    runs-on: windows-latest
    strategy:
      fail-fast: false
      matrix:
        include:
          - windows-version: "0.61.3"
          # Skip 0.62.x since we already test current version in test-native
    name: test-windows-v${{ matrix.windows-version }}
    steps:
      - uses: actions/checkout@v5

      - name: Install dependencies
        run: |
          choco install llvm

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2
        with:
          key: windows-v${{ matrix.windows-version }}

      - name: Lock windows crate to specific version
        shell: bash
        run: |
          # Generate Cargo.lock first if it doesn't exist
          cargo generate-lockfile

          # Use cargo update --precise to lock the windows crate to a specific version
          cargo update --precise ${{ matrix.windows-version }} windows

          # Remove and re-add `windows-core` to force Cargo to re-resolve it
          # I'd prefer a more surgical approach, but things get complicated once multiple `windows-core`
          # versions are in play
          cargo rm --target='cfg(target_os = "windows")' windows-core
          cargo add --target='cfg(target_os = "windows")' windows-core@*

          # Verify the version was locked correctly
          echo "Locked windows crate version:"
          cargo tree | grep "windows v" || echo "Windows crate not found in dependency tree"

          # Also check Cargo.lock
          echo "Cargo.lock entry:"
          grep -A 5 "name = \"windows\"" Cargo.lock | head -10

      - name: Check WASAPI with windows v${{ matrix.windows-version }}
        run: |
          cargo check --verbose