ci.yml

name: Rust
on:
  push:
    branches:
      - "*"
  pull_request:

# Only run on the latest ref
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

jobs:
  format:
    name: Format
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: true
      - name: Setup Rust
        uses: dtolnay/rust-toolchain@v1
        with:
          toolchain: stable
          components: rustfmt
      - name: Cargo cache
        uses: actions/cache@v3
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
          key: ${{ runner.os }}-cargo-rust_stable-${{ hashFiles('**/Cargo.lock') }}
      - name: Format
        run: cargo fmt --all -- --check

  doc:
    name: Documentation
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: true
      - name: Setup Rust
        uses: dtolnay/rust-toolchain@v1
        with:
          toolchain: nightly
          components: rust-docs
      - name: Cargo cache
        uses: actions/cache@v3
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
          key: ${{ runner.os }}-cargo-rust_nightly-${{ hashFiles('**/Cargo.lock') }}
      - name: Build cache
        uses: actions/cache@v3
        with:
          path: target
          key: ${{ runner.os }}-build-rust_nightly-doc-${{ hashFiles('**/Cargo.lock') }}
      - name: Documentation
        env:
          DOCS_RS: 1
        run: cargo doc --no-deps --features full-async,parallel,doc-cfg
      - name: Upload docs
        uses: actions/upload-artifact@v3
        with:
          name: docs
          path: |
            target/doc/rquickjs
            target/doc/rquickjs-sys
            target/doc/rquickjs-macro
  check:
    name: Clippy check
    runs-on: ubuntu-latest
    permissions:
      checks: write
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: true
      - uses: dtolnay/rust-toolchain@v1
        with:
          toolchain: nightly
          components: clippy
      - name: Cargo cache
        uses: actions/cache@v3
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
          key: ${{ runner.os }}-cargo-rust_nightly-${{ hashFiles('**/Cargo.lock') }}
      - name: Build cache
        uses: actions/cache@v3
        with:
          path: target
          key: ${{ runner.os }}-build-rust_nightly-check-${{ hashFiles('**/Cargo.lock') }}
      - name: Cargo clippy
        run: cargo clippy --all --all-targets --features full-async

  msrv:
    name: Minimal rust version
    # Check to see if rquickjs builds on minimal supported Rust version.
    runs-on: ubuntu-latest
    # we use a matrix here just because env can't be used in job names
    # https://docs.github.com/en/actions/learn-github-actions/contexts#context-availability
    strategy:
      matrix:
        msrv: [1.65.0] # 1.65.0 introduced GAT stabilization
    name: ubuntu / ${{ matrix.msrv }}
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: true
      - name: Install ${{ matrix.msrv }}
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ matrix.msrv }}
      - name: cargo +${{ matrix.msrv }} check
        run: cargo check

  coverage:
    name: Test + Converage
    runs-on: ubuntu-latest
    steps:
      - uses: dtolnay/rust-toolchain@v1
        with:
          toolchain: nightly
          components: clippy
      - uses: actions/checkout@v3
        with:
          submodules: true
      - name: Build cache
        uses: actions/cache@v3
        with:
          path: target
          key: ${{ runner.os }}-build-rust_nightly-check-${{ hashFiles('**/Cargo.lock') }}

      - name: Install dependencies
        run: |
          sudo apt-get -y update
          sudo apt-get -y install protobuf-compiler libprotobuf-dev

      - name: Install cargo-llvm-cov
        uses: taiki-e/install-action@cargo-llvm-cov

      - name: Run cargo test coverage
        run: cargo llvm-cov --html --no-default-features --features full-async,compile-tests --workspace

      - name: Upload coverage report
        uses: actions/upload-artifact@v3
        with:
            name: code-coverage-report
            path: target/llvm-cov/html/
            retention-days: 5

  test:
    name: Platform tests
    needs:
      - format
      - doc
      - check
      - msrv
      - coverage
    strategy:
      fail-fast: ${{ startsWith(github.ref, 'refs/tags/') }}
      matrix:
        include:
          # Generate bindings
          - task: bindings
            os: ubuntu-latest
            rust: stable
            target: i686-unknown-linux-gnu
            features: exports
            optimization: false
          - task: bindings
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-gnu
            features: exports
            optimization: false
          - task: bindings
            os: macos-latest
            rust: stable
            target: x86_64-apple-darwin
            features: full-async
            optimization: false
          - task: bindings
            os: macos-latest
            rust: stable
            target: aarch64-apple-darwin
            features: full-async
            optimization: false
          - task: bindings
            os: windows-latest
            rust: stable
            target: i686-pc-windows-gnu
            features: full-async
            optimization: false
          - task: bindings
            os: windows-latest
            rust: stable
            target: x86_64-pc-windows-gnu
            features: full-async
            optimization: false
          - task: bindings
            os: windows-latest
            rust: stable
            target: i686-pc-windows-msvc
            features: full-async
            optimization: false
          - task: bindings
            os: windows-latest
            rust: stable
            target: x86_64-pc-windows-msvc
            features: full-async
            optimization: false
          - task: bindings
            os: windows-latest
            rust: stable
            target: x86_64-pc-windows-msvc
            features: full-async
            optimization: true
          - task: bindings
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-musl
            features: full-async
            optimization: false
          - task: bindings
            os: ubuntu-latest
            rust: stable
            target: aarch64-unknown-linux-musl
            features: full-async
            optimization: false
          - task: bindings
            os: ubuntu-latest
            rust: stable
            target: aarch64-unknown-linux-gnu
            features: full-async
            optimization: false
          # Test features
          - task: features
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-gnu
            features: exports
            optimization: false
          - task: features
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-gnu
            features: rust-alloc
            optimization: false
          - task: features
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-gnu
            features: loader
            optimization: false
          - task: features
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-gnu
            features: classes
            optimization: false
          - task: features
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-gnu
            features: properties
            optimization: false
          - task: features
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-gnu
            features: futures
            optimization: false
          - task: features
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-gnu
            features: parallel
            optimization: false
          # Test channels
          - task: channels
            os: ubuntu-latest
            rust: stable
            target: x86_64-unknown-linux-gnu
            features: full-async
            optimization: false
          - task: channels
            os: ubuntu-latest
            rust: beta
            target: x86_64-unknown-linux-gnu
            features: full-async
            optimization: false
          - task: channels
            os: ubuntu-latest
            rust: nightly
            target: x86_64-unknown-linux-gnu
            features: full-async
            optimization: false
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: true
      - name: Setup cross linux toolchain
        if: contains(matrix.target, '-linux-') && !startsWith(matrix.target, 'aarch64') && !startsWith(matrix.target, 'x86_64-') && !endsWith(matrix.target, '-musl')
        run: |
          case "${{ matrix.target }}" in
            i686-*) SYSTEM_ARCH=i386 ;;
          esac
          GCC_TARGET=$(printf "${{ matrix.target }}" | sed 's/-unknown-/-/' | sed 's/arm[^-]*/arm/g')
          ENV_TARGET=$(printf "${{ matrix.target }}" | tr '[:lower:]' '[:upper:]' | tr '-' '_')
          sudo dpkg --add-architecture ${SYSTEM_ARCH}
          sudo apt-get update -y
          sudo apt-get install -y libc6-dev:${SYSTEM_ARCH} gcc-${GCC_TARGET} libgcc-s1:${SYSTEM_ARCH}
          echo "CARGO_TARGET_${ENV_TARGET}_LINKER=${GCC_TARGET}-gcc" >> $GITHUB_ENV
      - name: Setup musl-tools
        if: startsWith(matrix.target, 'x86_64-') && endsWith(matrix.target, '-musl')
        run: sudo apt-get update -y && sudo apt-get install -y musl-tools
      - name: Setup musl aarch64
        if: startsWith(matrix.target, 'aarch64') && contains(matrix.target, '-linux-')
        run: |
          sudo apt-get update -y
          sudo apt-get install -y \
            curl \
            libc6-arm64-cross \
            libc6-dev-arm64-cross \
            crossbuild-essential-arm64 \
            clang \
            qemu-system-arm \
            qemu-efi-aarch64 \
            qemu-utils \
            qemu-user

          curl --retry 5 https://musl.cc/aarch64-linux-musl-cross.tgz | tar xzf -
          sudo mv aarch64-linux-musl-cross /musl

          echo "CC_aarch64_unknown_linux_musl=aarch64-linux-musl-gcc" >> $GITHUB_ENV
          echo "CXX_aarch64_unknown_linux_musl=aarch64-linux-musl-g++" >> $GITHUB_ENV
          echo "AR_aarch64_unknown_linux_musl=aarch64-linux-musl-ar" >> $GITHUB_ENV
          echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER=aarch64-linux-musl-gcc" >> $GITHUB_ENV
          echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_RUNNER=qemu-aarch64" >> $GITHUB_ENV

          echo "CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc" >> $GITHUB_ENV
          echo "CXX_aarch64_unknown_linux_gnu=aarch64-linux-gnu-g++" >> $GITHUB_ENV
          echo "AR_aarch64_unknown_linux_gnu=aarch64-linux-gnu-ar" >> $GITHUB_ENV
          echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc" >> $GITHUB_ENV
          echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUNNER=qemu-aarch64" >> $GITHUB_ENV

          echo "LD_LIBRARY_PATH=/usr/aarch64-linux-gnu/lib" >> $GITHUB_ENV

          sudo ln -s /usr/aarch64-linux-gnu/lib/ld-linux-aarch64.so.1 /lib/ld-linux-aarch64.so.1

          mkdir -p ~/.cargo/
          echo "[target.aarch64-unknown-linux-musl]" >> ~/.cargo/config.toml
          echo 'rustflags = ["-C", "link-self-contained=yes","-C", "linker=rust-lld"]' >> ~/.cargo/config.toml
          echo "[target.aarch64-unknown-linux-gnu]" >> ~/.cargo/config.toml
          echo 'rustflags = ["-C", "linker=aarch64-linux-gnu-gcc"]' >> ~/.cargo/config.toml

          echo "/musl/bin" >> $GITHUB_PATH
      - name: Setup msys2 toolchains
        if: startsWith(matrix.os, 'windows') && endsWith(matrix.target, '-gnu')
        uses: msys2/setup-msys2@v2
        with:
          release: false
          install: mingw-w64-x86_64-gcc mingw-w64-i686-gcc
      - name: Prepare env for windows
        if: startsWith(matrix.os, 'windows') && endsWith(matrix.target, '-gnu')
        run: |
          # Add symlinks to the target-specific GNU sysroots for Clang
          New-Item -Path "C:\Program Files\LLVM\x86_64-w64-mingw32" -ItemType SymbolicLink -Value "C:\msys64\mingw64\x86_64-w64-mingw32"
          New-Item -Path "C:\Program Files\LLVM\i686-w64-mingw32" -ItemType SymbolicLink -Value "C:\msys64\mingw64\i686-w64-mingw32"
          # Add paths to GCC executables to PATH
          echo "C:\msys64\mingw64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
          echo "C:\msys64\mingw32\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
          # Configure CC_<target> environment variables
          echo "CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
          echo "CC_i686_pc_windows_gnu=i686-w64-mingw32-gcc" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
          # echo "HOST_CC=x86_64-w64-mingw32-gcc" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
      - name: Setup Rust
        uses: dtolnay/rust-toolchain@v1
        with:
          toolchain: ${{ matrix.rust }}
          targets: ${{ matrix.target }}
          components: rustfmt
      - name: Cargo cache
        uses: actions/cache@v3
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
          key: ${{ runner.os }}-cargo-rust_${{ matrix.rust }}-${{ hashFiles('**/Cargo.lock') }}
      - name: Build cache
        if: |
          runner.os != 'macOS'
        uses: actions/cache@v3
        with:
          path: target
          key: ${{ runner.os }}-build-rust_${{ matrix.rust }}-target_${{ matrix.target }}-opt_${{ matrix.optimization }}-${{ hashFiles('**/Cargo.lock') }}
      - name: Update deps
        run: cargo update
      - name: Build sys
        env:
          RUST_LOG: bindgen=warn,bindgen::ir=error,bindgen::codegen=error
        run: |
          cargo clean
          cargo build ${{ matrix.optimization && '--release' || '' }} --manifest-path sys/Cargo.toml --target ${{ matrix.target }} --features exports,bindgen,update-bindings,logging
      - name: Upload bindings
        if: matrix.task == 'bindings'
        uses: actions/upload-artifact@v3
        with:
          name: bindings
          path: sys/src/bindings/${{ matrix.target }}.rs
      - name: Build
        run: cargo build ${{ matrix.optimization && '--release' || '' }} --target ${{ matrix.target }} --no-default-features --features ${{ matrix.features }}
      - name: Test
        if: |
          matrix.target != 'aarch64-apple-darwin'
        timeout-minutes: 12
        env:
          RUST_BACKTRACE: full
        run: cargo test ${{ matrix.optimization && '--release' || '' }} --all --target ${{ matrix.target }} --no-default-features --features ${{ matrix.features }}

  results:
    if: ${{ always() }}
    runs-on: ubuntu-latest
    name: Platform test results
    needs: [test]
    steps:
      - run: exit 1
        if: >-
          ${{
            contains(needs.*.results, 'failure')
            || contains(needs.*.results, 'cancelled')
          }}

  update-bindings:
    name: Update bindings
    if: ${{ github.event_name != 'pull_request' && !startsWith(github.ref, 'refs/tags/') }}
    needs:
      - test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Download bindings
        uses: actions/download-artifact@v3
        with:
          name: bindings
          path: sys/src/bindings
      - name: Create pull request
        uses: peter-evans/create-pull-request@v4
        with:
          base: ${{ github.head_ref }}
          commit-message: Updated bindings
          branch: update-bindings
          delete-branch: true
          title: Update bindings
          body: |
            Bindings should be updated to be consistent with latest changes